@heartlandone/vega 2.95.0 → 2.96.0

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy.js

@@ -1,36 +1,187 @@
 import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
 import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
 import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { normalizeMixedListSelection } from './list-transform-selection';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Convert the selected blocks to list strategy.
  */
-export class ListTransformToListStrategy extends ActionHandleStrategy {
+export class ListTransformToListStrategy extends ListAnnotationStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
+    var _a;
     const selectedBlocks = action.selectedBlocks;
-    const bulletList = target.parent.createList(action.listType);
     const isSameList = selectedBlocks.every((block) => block.parent === target);
+    const rootContent = this.getRootContent(target);
+    if (!rootContent) {
+      return;
+    }
+    // Nested list case: target.parent is RTEListItemBlock, not VegaRTEContent.
+    // Replace the entry in the parent item's nestList using the existing ReplaceNestListAction.
+    if (target.parent instanceof RTEListItemBlock) {
+      if (isSameList) {
+        const newList = this.createListFromSource(rootContent, target, action.listType);
+        newList.apply(new AppendChildrenAction(target.children));
+        const parentListItem = target.parent;
+        const newNestList = ((_a = parentListItem.nestList) !== null && _a !== void 0 ? _a : []).map((list) => (list === target ? newList : list));
+        // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+        parentListItem.apply(new ReplaceNestListAction(newNestList));
+        selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+      }
+      else {
+        this.handleCrossListTransform(action, target);
+      }
+      return;
+    }
+    // Root list case: target.parent is VegaRTEContent.
+    // When all selected blocks are list items from different lists, convert each
+    // affected list's type in place (preserving nesting), then normalize adjacent
+    // same-type root lists into one.
+    if (!isSameList && selectedBlocks.every((block) => block instanceof RTEListItemBlock)) {
+      const affectedLists = new Set(selectedBlocks.map((block) => block.parent));
+      // Track which root lists result from conversion (new lists replace old ones).
+      const convertedRootLists = new Set();
+      affectedLists.forEach((list) => {
+        if (list.type !== action.listType) {
+          this.convertListTypeInPlace(list, action.listType);
+        }
+      });
+      // Collect current top-level lists that contain any selected item, grouped
+      // by their root or HTML-block container.
+      const affectedContainers = new Set();
+      selectedBlocks.forEach((block) => {
+        const parentList = block.parent;
+        if (!(parentList.parent instanceof RTEListItemBlock)) {
+          convertedRootLists.add(parentList);
+          affectedContainers.add(parentList.parent);
+        }
+      });
+      // Only merge adjacent root lists when BOTH are affected by this transform.
+      affectedContainers.forEach((container) => {
+        for (let i = 0; i < container.children.length - 1;) {
+          const current = container.children[i];
+          const next = container.children[i + 1];
+          if (current instanceof RTEListBlock &&
+            next instanceof RTEListBlock &&
+            current.type === next.type &&
+            this.haveSameListAnnotations(current, next) &&
+            convertedRootLists.has(current) &&
+            convertedRootLists.has(next)) {
+            current.apply(new AppendChildrenAction([...next.children]));
+            container.apply(new RemoveChildrenAction(next));
+            convertedRootLists.delete(next);
+          }
+          else {
+            i++;
+          }
+        }
+      });
+      selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+      return;
+    }
+    const bulletList = this.createListFromSource(rootContent, target, action.listType);
+    const targetContainer = target.parent;
     if (isSameList) {
       // Select one or more list items belonging to the same list, and all items in this list should be updated
       bulletList.apply(new AppendChildrenAction(target.children));
-      target.parent.apply(new InsertChildrenAfterAction(target, bulletList));
-      target.parent.apply(new RemoveChildrenAction(target));
+      targetContainer.apply(new InsertChildrenAfterAction(target, bulletList));
+      targetContainer.apply(new RemoveChildrenAction(target));
       selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
     }
     else {
-      const listItems = action.selectedBlocks.map((block) => target.parent.toListItem(block));
+      const mixedSelection = normalizeMixedListSelection(action.selectedBlocks, action.listType);
+      const listItems = mixedSelection.map((block) => rootContent.toListItem(block));
       bulletList.apply(new AppendChildrenAction(listItems));
-      target.parent.apply(new InsertChildrenAfterAction(target, bulletList));
-      action.selectedBlocks.forEach((block) => {
+      targetContainer.apply(new InsertChildrenAfterAction(target, bulletList));
+      mixedSelection.forEach((block) => {
         block.parent.apply(new RemoveChildrenAction(block));
       });
       if (target.children.length === 0) {
-        target.parent.apply(new RemoveChildrenAction(target));
+        targetContainer.apply(new RemoveChildrenAction(target));
       }
     }
   }
+  /**
+   * Convert a single list's type in place, preserving its items and their nested
+   * structure. Root lists are swapped in the content children; nested lists are
+   * swapped inside their parent item's nestList.
+   *
+   * @param {RTEListBlock} list - The list whose type should be converted.
+   * @param {RTEListBlock['type']} listType - The target list type.
+   */
+  convertListTypeInPlace(list, listType) {
+    var _a;
+    const rootContent = this.getRootContent(list);
+    if (!rootContent) {
+      return;
+    }
+    const parent = list.parent;
+    const newList = this.createListFromSource(rootContent, list, listType);
+    newList.apply(new AppendChildrenAction([...list.children]));
+    if (parent instanceof RTEListItemBlock) {
+      // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+      const newNestList = ((_a = parent.nestList) !== null && _a !== void 0 ? _a : []).map((entry) => entry === list ? newList : entry);
+      parent.apply(new ReplaceNestListAction(newNestList));
+    }
+    else {
+      parent.apply(new InsertChildrenAfterAction(list, newList));
+      parent.apply(new RemoveChildrenAction(list));
+    }
+  }
+  /**
+   * Handle the case where selected blocks span multiple nestLists under the same parent item.
+   * Transform each affected list and then merge adjacent same-type lists.
+   *
+   * @param {TransformListAction} action - The transform action with selection and target list type.
+   * @param {RTEListBlock} target - The nested list where transformation starts.
+   */
+  handleCrossListTransform(action, target) {
+    if (!(target.parent instanceof RTEListItemBlock)) {
+      return;
+    }
+    const rootContent = this.getRootContent(target);
+    if (!rootContent) {
+      return;
+    }
+    const parentListItem = target.parent;
+    const parentNestLists = parentListItem.nestList;
+    const affectedLists = new Set(action.selectedBlocks
+      .filter((block) => block instanceof RTEListItemBlock)
+      .map((block) => block.parent)
+      .filter((list) => parentNestLists.includes(list)));
+    if (!affectedLists.size) {
+      return;
+    }
+    const newNestList = parentNestLists.map((list) => {
+      if (!affectedLists.has(list)) {
+        return list;
+      }
+      const newList = this.createListFromSource(rootContent, list, action.listType);
+      newList.apply(new AppendChildrenAction(list.children));
+      return newList;
+    });
+    // Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy.
+    parentListItem.apply(new ReplaceNestListAction(newNestList));
+    action.selectedBlocks.forEach((block) => block.children.map((node) => node.apply(new SyncUpSelectionAction())));
+  }
+  /**
+   * Create a replacement list through the owning content factory while retaining
+   * the source list's container annotations.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content owning the factory.
+   * @param {RTEListBlock} source - List whose annotations should be retained.
+   * @param {RTEListBlock['type']} listType - Replacement list type.
+   * @returns {RTEListBlock} New annotated list shell.
+   */
+  createListFromSource(rootContent, source, listType) {
+    const list = rootContent.createList(listType);
+    this.copyListAnnotations(source, list);
+    return list;
+  }
 }

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy.js

@@ -3,50 +3,416 @@ import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
 import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
 import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
 import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { TransformParagraphAction } from '../../actions/transform-paragraph-action';
+import { RTEHtmlBlock } from '../../blocks/html-block';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RTETextBlock } from '../../blocks/text-block';
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Convert the selected list block to paragraph strategy.
  */
-export class ListTransformToParagraphStrategy extends ActionHandleStrategy {
+export class ListTransformToParagraphStrategy extends ListAnnotationStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
+    const selectedSegments = this.getSelectedSegments(action.selectedBlocks);
+    if (selectedSegments.length === 0 || !this.hasConsistentTargetAndRoot(selectedSegments, target)) {
+      return;
+    }
+    this.syncSelection(selectedSegments);
+    [...selectedSegments]
+      .reverse()
+      .forEach((segment) => this.transformSegment(segment));
+  }
+  /**
+   * Ensure the action is applied to the first selected item's parent list and
+   * every selected item belongs to the same editor content.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   * @param {RTEListBlock} target - List receiving the transform action.
+   * @returns {boolean} Whether the target and root content are consistent.
+   */
+  hasConsistentTargetAndRoot(selectedSegments, target) {
+    if (selectedSegments[0][0].parent !== target) {
+      return false;
+    }
+    const targetRoot = this.getRootContent(target);
+    return Boolean(targetRoot &&
+      selectedSegments.every((segment) => segment.every((item) => this.getRootContent(item) === targetRoot)));
+  }
+  /**
+   * Capture selected text nodes in document order before reverse-order tree
+   * mutations move them into paragraphs.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   */
+  syncSelection(selectedSegments) {
+    selectedSegments.forEach((segment) => {
+      segment.forEach((block) => {
+        block.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+      });
+    });
+  }
+  /**
+   * Transform one normalized segment without recursively dispatching another
+   * flushable action.
+   *
+   * @param {RTEListItemBlock[]} segment - Contiguous items sharing one parent list.
+   */
+  transformSegment(segment) {
+    const segmentTarget = segment[0].parent;
+    const normalizedAction = new TransformParagraphAction(segment);
+    if (segmentTarget.parent instanceof RTEListItemBlock) {
+      this.handleNestedListCase(normalizedAction, segmentTarget);
+      return;
+    }
+    this.handleRootListCase(normalizedAction, segmentTarget);
+  }
+  /**
+   * Handle the case where the target list is at root level (parent is VegaRTEContent).
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The root list being transformed.
+   */
+  handleRootListCase(action, target) {
+    // handleAction validates that the target belongs to an editor content root.
+    const rootContent = this.getRootContent(target);
     let isSelectedFirstBlock = false;
     let isSelectedLastBlock = false;
     const selectedBlocks = action.selectedBlocks;
-    const currentParagraph = selectedBlocks.map((block) => {
-      block.children.map((node) => node.apply(new SyncUpSelectionAction()));
+    // Build an operation-local insertion sequence. Paragraphs are merge
+    // boundaries; only consecutive same-type promoted lists are merged.
+    const insertionBlocks = [];
+    selectedBlocks.forEach((block) => {
+      var _a;
       if (block === target.children[0])
         isSelectedFirstBlock = true;
       if (block === target.children[target.children.length - 1])
         isSelectedLastBlock = true;
-      return this.toParagraph(block);
+      insertionBlocks.push(this.toParagraph(block));
+      for (const nestList of (_a = block.nestList) !== null && _a !== void 0 ? _a : []) {
+        this.appendListBlock(insertionBlocks, nestList);
+      }
     });
     if (isSelectedFirstBlock) {
-      target.parent.apply(new InsertChildrenBeforeAction(target, ...currentParagraph));
+      target.parent.apply(new InsertChildrenBeforeAction(target, ...insertionBlocks));
     }
     else if (isSelectedLastBlock) {
-      target.parent.apply(new InsertChildrenAfterAction(target, ...currentParagraph));
+      target.parent.apply(new InsertChildrenAfterAction(target, ...insertionBlocks));
     }
     else {
       const startIndex = target.children.indexOf(selectedBlocks[0]);
       const lastIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
-      const firstBulletList = target.parent.createList(target.type);
+      const firstBulletList = this.createListFromSource(rootContent, target);
       firstBulletList.apply(new AppendChildrenAction(target.children.slice(0, startIndex)));
-      const lastBulletList = target.parent.createList(target.type);
+      const lastBulletList = this.createListFromSource(rootContent, target);
       lastBulletList.apply(new AppendChildrenAction(target.children.slice(lastIndex + 1)));
-      target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...currentParagraph, lastBulletList));
+      // Merge last insertionBlock with lastBulletList if same type
+      const lastInsertion = insertionBlocks[insertionBlocks.length - 1];
+      if (lastInsertion instanceof RTEListBlock &&
+        lastBulletList.children.length > 0 &&
+        lastInsertion.type === lastBulletList.type &&
+        this.haveSameListAnnotations(lastInsertion, lastBulletList)) {
+        lastInsertion.apply(new AppendChildrenAction(lastBulletList.children));
+        target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...insertionBlocks));
+      }
+      else {
+        target.parent.apply(new InsertChildrenBeforeAction(target, firstBulletList, ...insertionBlocks, lastBulletList));
+      }
       target.parent.apply(new RemoveChildrenAction(target));
     }
     selectedBlocks.map((block) => {
+      // Clear nestList before removal to prevent ListRemoveListItemStrategy
+      // from promoting the same nested lists a second time.
+      block.nestList = [];
       target.apply(new RemoveChildrenAction(block));
     });
     if (target.children.length === 0) {
       target.parent.apply(new RemoveChildrenAction(target));
     }
+    else if (isSelectedFirstBlock) {
+      // When removing the first item(s), a promoted same-type nestList (last
+      // insertionBlock) ends up immediately before the remaining target. Merge
+      // them so the user doesn't see two adjacent same-type lists.
+      const lastInserted = insertionBlocks[insertionBlocks.length - 1];
+      if (lastInserted instanceof RTEListBlock &&
+        lastInserted.type === target.type &&
+        this.haveSameListAnnotations(lastInserted, target)) {
+        lastInserted.apply(new AppendChildrenAction([...target.children]));
+        target.parent.apply(new RemoveChildrenAction(target));
+      }
+    }
+  }
+  /**
+   * Handle the case where the target list is nested (parent is RTEListItemBlock).
+   *
+   * Algorithm:
+   * 1. Build the ancestor path from root list down to the target nested list.
+   * 2. At each level on the path, collect "trailing" items (items after the ancestor).
+   * 3. Trim each list along the path to keep only the "before" portion.
+   * 4. Collect trailing items from all levels + selected item's own nestList children.
+   * 5. Group trailing items into lists by consecutive type.
+   * 6. Insert into content: [before-root-list, paragraphs, ...after-lists].
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The nested list being transformed.
+   */
+  handleNestedListCase(action, target) {
+    const selectedBlocks = action.selectedBlocks;
+    const rootContent = this.getRootContent(target);
+    const selectedItem = selectedBlocks[0];
+    const selectedIndex = target.children.indexOf(selectedItem);
+    // Emit each selected item as paragraph + its own nested lists so that
+    // selecting multiple levels never moves a child list past another paragraph.
+    const insertions = [];
+    selectedBlocks.forEach((block) => {
+      var _a;
+      insertions.push(this.toParagraph(block));
+      for (const nestList of (_a = block.nestList) !== null && _a !== void 0 ? _a : []) {
+        this.appendListBlock(insertions, nestList);
+      }
+    });
+    const lastSelectedIndex = target.children.indexOf(selectedBlocks[selectedBlocks.length - 1]);
+    // Collect trailing items from the nested list (items AFTER the last selected)
+    const nestedTrailingItems = target.children.slice(lastSelectedIndex + 1);
+    const ancestorPath = [];
+    let currentList = target;
+    while (currentList.parent instanceof RTEListItemBlock) {
+      const parentItem = currentList.parent;
+      const grandParentList = parentItem.parent;
+      const ancestorIndex = grandParentList.children.indexOf(parentItem);
+      // Collect nestLists of parentItem that are AFTER currentList
+      const parentNestLists = parentItem.nestList;
+      const nestListIndex = parentNestLists.indexOf(currentList);
+      const trailingNestLists = parentNestLists.slice(nestListIndex + 1);
+      ancestorPath.push({ list: grandParentList, ancestorIndex, trailingNestLists });
+      currentList = grandParentList;
+    }
+    // currentList is now the root-level list
+    const rootList = currentList;
+    const rootContainer = rootList.parent;
+    const trailingGroups = [];
+    // 1. Trailing items from the target nested list (same type as target)
+    if (nestedTrailingItems.length > 0) {
+      trailingGroups.push({ items: nestedTrailingItems, sourceList: target });
+    }
+    // 2. Trailing nestLists from ancestors (innermost to outermost)
+    // 3. Trailing items from each ancestor level's list
+    for (const level of ancestorPath) {
+      // Trailing nestLists from the ancestor item
+      for (const trailingNest of level.trailingNestLists) {
+        if (trailingNest.children.length > 0) {
+          trailingGroups.push({ items: [...trailingNest.children], sourceList: trailingNest });
+        }
+      }
+      // Trailing items from ancestor's list (items after the ancestor item)
+      const trailingFromLevel = level.list.children.slice(level.ancestorIndex + 1);
+      if (trailingFromLevel.length > 0) {
+        trailingGroups.push({ items: trailingFromLevel, sourceList: level.list });
+      }
+    }
+    // Merge only groups whose list type and container annotations match. Different
+    // class/style/attribute boundaries must survive the structural reconstruction.
+    const mergedGroups = [];
+    for (const group of trailingGroups) {
+      const prev = mergedGroups[mergedGroups.length - 1];
+      if (prev &&
+        prev.sourceList.type === group.sourceList.type &&
+        this.haveSameListAnnotations(prev.sourceList, group.sourceList)) {
+        prev.items.push(...group.items);
+      }
+      else {
+        mergedGroups.push({ items: [...group.items], sourceList: group.sourceList });
+      }
+    }
+    // Build the "after" lists
+    const afterLists = mergedGroups.map((group) => {
+      const newList = this.createListFromSource(rootContent, group.sourceList);
+      newList.apply(new AppendChildrenAction(group.items));
+      return newList;
+    });
+    afterLists.forEach((list) => this.appendListBlock(insertions, list));
+    // --- Now trim the "before" portion ---
+    // Trim target nested list: keep only items before selected
+    target.children = target.children.slice(0, selectedIndex);
+    // Clean up the target nested list's parent item's nestList
+    const targetParentItem = target.parent;
+    const targetParentNestLists = targetParentItem.nestList;
+    const targetNestIndex = targetParentNestLists.indexOf(target);
+    // Keep only nestLists up to and including the target (remove trailing ones we already collected)
+    let trimmedNestList = targetParentNestLists.slice(0, targetNestIndex + 1);
+    // If target is now empty, remove it too
+    if (target.children.length === 0) {
+      trimmedNestList = trimmedNestList.filter((l) => l !== target);
+    }
+    targetParentItem.apply(new ReplaceNestListAction(trimmedNestList));
+    // Trim ancestor levels: remove trailing items and trailing nestLists
+    for (const level of ancestorPath) {
+      // Remove trailing items from the ancestor's list
+      level.list.children = level.list.children.slice(0, level.ancestorIndex + 1);
+      // Remove trailing nestLists from the ancestor item
+      if (level.trailingNestLists.length > 0) {
+        const ancestorItem = level.list.children[level.ancestorIndex];
+        const ancestorNestLists = ancestorItem.nestList;
+        const firstTrailingNestIndex = ancestorNestLists.indexOf(level.trailingNestLists[0]);
+        if (firstTrailingNestIndex >= 0) {
+          const keptNestLists = ancestorNestLists.slice(0, firstTrailingNestIndex);
+          ancestorItem.apply(new ReplaceNestListAction(keptNestLists));
+        }
+      }
+    }
+    rootContainer.apply(new InsertChildrenAfterAction(rootList, ...insertions));
+  }
+  /**
+   * Normalize selected items into document order and split them into contiguous
+   * segments that share the same immediate parent list. Unlike Shift+Tab, the
+   * toolbar action keeps selected descendants so every selected item becomes a
+   * paragraph.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[][]} Parent-based contiguous selection segments.
+   */
+  getSelectedSegments(selectedBlocks) {
+    const selectedItems = Array.from(new Set(selectedBlocks.filter((block) => block instanceof RTEListItemBlock)))
+      .map((item) => ({ item, path: this.getStructuralPath(item) }))
+      .filter((entry) => entry.path !== null)
+      .sort((a, b) => this.compareStructuralPaths(a.path, b.path))
+      .map((entry) => entry.item);
+    const segments = [];
+    for (const item of selectedItems) {
+      const segment = segments[segments.length - 1];
+      const previousItem = segment === null || segment === void 0 ? void 0 : segment[segment.length - 1];
+      const isContiguousSibling = (previousItem === null || previousItem === void 0 ? void 0 : previousItem.parent) === item.parent &&
+        item.parent.children.indexOf(item) - item.parent.children.indexOf(previousItem) === 1;
+      if (isContiguousSibling) {
+        segment.push(item);
+      }
+      else {
+        segments.push([item]);
+      }
+    }
+    return segments;
+  }
+  /**
+   * Resolve a list item's structural document path, including the positions of
+   * root lists, owning list items, nested lists, and the item itself.
+   *
+   * @param {RTEListItemBlock} item - Selected list item.
+   * @returns {number[] | null} Structural path, or null for a detached item.
+   */
+  getStructuralPath(item) {
+    var _a;
+    const path = [];
+    const visitedLists = new Set();
+    let currentItem = item;
+    let currentList = item.parent;
+    while (!visitedLists.has(currentList)) {
+      visitedLists.add(currentList);
+      const itemIndex = currentList.children.indexOf(currentItem);
+      if (itemIndex < 0) {
+        return null;
+      }
+      path.unshift(itemIndex);
+      if (currentList.parent.dtoName === 'VegaRTEContent' ||
+        currentList.parent.dtoName === 'RTEHtmlBlock') {
+        const containerPath = this.getContainerPath(currentList);
+        return containerPath ? [...containerPath, ...path] : null;
+      }
+      if (!(currentList.parent instanceof RTEListItemBlock)) {
+        return null;
+      }
+      const ownerItem = currentList.parent;
+      const nestListIndex = ((_a = ownerItem.nestList) !== null && _a !== void 0 ? _a : []).indexOf(currentList);
+      if (nestListIndex < 0) {
+        return null;
+      }
+      path.unshift(nestListIndex);
+      currentItem = ownerItem;
+      currentList = ownerItem.parent;
+    }
+    return null;
+  }
+  /**
+   * Resolve a root list's path through zero or more HTML containers to the
+   * editor content.
+   *
+   * @param {RTEListBlock} rootList - List whose parent is a content container.
+   * @returns {number[] | null} Container path, or null for detached/cyclic ownership.
+   */
+  getContainerPath(rootList) {
+    const path = [];
+    const visitedContainers = new Set();
+    let child = rootList;
+    let container = rootList.parent;
+    while (container instanceof RTEHtmlBlock) {
+      if (visitedContainers.has(container)) {
+        return null;
+      }
+      visitedContainers.add(container);
+      const childIndex = container.children.indexOf(child);
+      if (childIndex < 0) {
+        return null;
+      }
+      path.unshift(childIndex);
+      child = container;
+      container = container.parent;
+    }
+    const rootChildIndex = container.children.indexOf(child);
+    if (rootChildIndex < 0) {
+      return null;
+    }
+    path.unshift(rootChildIndex);
+    return path;
+  }
+  /**
+   * Compare two structural paths in document order.
+   *
+   * @param {number[]} firstPath - First structural path.
+   * @param {number[]} secondPath - Second structural path.
+   * @returns {number} Relative document order.
+   */
+  compareStructuralPaths(firstPath, secondPath) {
+    const length = Math.min(firstPath.length, secondPath.length);
+    for (let index = 0; index < length; index++) {
+      if (firstPath[index] !== secondPath[index]) {
+        return firstPath[index] - secondPath[index];
+      }
+    }
+    return firstPath.length - secondPath.length;
+  }
+  /**
+   * Append a list to an operation-local block sequence, merging only with the
+   * immediately preceding same-type list in that sequence.
+   *
+   * @param {RTEBlock[]} blocks - Operation-local output sequence.
+   * @param {RTEListBlock} list - List to append or merge.
+   */
+  appendListBlock(blocks, list) {
+    const previousBlock = blocks[blocks.length - 1];
+    if (previousBlock instanceof RTEListBlock &&
+      previousBlock.type === list.type &&
+      this.haveSameListAnnotations(previousBlock, list)) {
+      previousBlock.apply(new AppendChildrenAction([...list.children]));
+      return;
+    }
+    blocks.push(list);
+  }
+  /**
+   * Create a list through the content factory and retain the source list's
+   * container annotations when a structural split requires a new list block.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content that owns the factory.
+   * @param {RTEListBlock} source - List whose type and annotations should be retained.
+   * @returns {RTEListBlock} Newly created list shell.
+   */
+  createListFromSource(rootContent, source) {
+    const list = rootContent.createList(source.type);
+    this.copyListAnnotations(source, list);
+    return list;
   }
   /**
    * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.