@heartlandone/vega 2.94.0 → 2.96.0

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.

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

@@ -0,0 +1,104 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { AbstractListItemsStrategy } from './list-items-strategy.abstract';
+/**
+ * Promote selected nested list items one level up.
+ */
+export class ListUnnestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    const parentListParent = target.parent;
+    if (!selectedItems.length || !(parentListParent instanceof RTEListItemBlock)) {
+      return;
+    }
+    const selectedStartIndex = target.children.indexOf(selectedItems[0]);
+    const selectedEndIndex = target.children.indexOf(selectedItems[selectedItems.length - 1]);
+    if (selectedStartIndex < 0 || selectedEndIndex < selectedStartIndex) {
+      return;
+    }
+    const parentListItem = parentListParent;
+    const grandParentList = parentListItem.parent;
+    const insertAfterIndex = grandParentList.children.indexOf(parentListItem);
+    if (insertAfterIndex < 0) {
+      return;
+    }
+    const trailingSiblingItems = target.children.slice(selectedEndIndex + 1);
+    const selectedItemSet = new Set(selectedItems);
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    grandParentList.children = [
+      ...grandParentList.children.slice(0, insertAfterIndex + 1),
+      ...selectedItems,
+      ...grandParentList.children.slice(insertAfterIndex + 1),
+    ];
+    selectedItems.forEach((item) => {
+      item.parent = grandParentList;
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+    if (trailingSiblingItems.length > 0) {
+      const trailingSiblingSet = new Set(trailingSiblingItems);
+      target.children = target.children.filter((item) => !trailingSiblingSet.has(item));
+      const newParentItem = selectedItems[selectedItems.length - 1];
+      let nestedList = (_a = newParentItem.nestList) === null || _a === void 0 ? void 0 : _a[newParentItem.nestList.length - 1];
+      // Shift+Tab follows same-type guard: when the last nested list has a
+      // different type, create a new child list of target.type instead of merging.
+      if (nestedList && nestedList.type !== target.type) {
+        nestedList = null;
+      }
+      if (!nestedList) {
+        nestedList = new RTEListBlock(generateUUID(), target.type);
+        const existingNestLists = Array.isArray(newParentItem.nestList)
+          ? newParentItem.nestList
+          : [];
+        newParentItem.apply(new ReplaceNestListAction([...existingNestLists, nestedList]));
+      }
+      nestedList.children = nestedList.children.concat(trailingSiblingItems);
+      trailingSiblingItems.forEach((item) => {
+        item.parent = nestedList;
+      });
+    }
+    // Lists after target are visually after every target item. Once selected items
+    // move above their former parent, transfer those later branches to the last
+    // selected item even when target still contains leading items; otherwise the
+    // branches render before the promoted selection and document order changes.
+    const trailingNestLists = this.collectTrailingNestLists(parentListItem, target);
+    if (trailingNestLists.length > 0) {
+      const lastSelected = selectedItems[selectedItems.length - 1];
+      const existingNest = Array.isArray(lastSelected.nestList)
+        ? lastSelected.nestList
+        : [];
+      lastSelected.apply(new ReplaceNestListAction([...existingNest, ...trailingNestLists]));
+    }
+    if (target.children.length === 0) {
+      parentListItem.apply(new RemoveNestListAction(target));
+    }
+  }
+  /**
+   * Collect and remove nestList entries that appear after the given target list
+   * in the parent item's nestList array. These trailing entries need to be
+   * transferred to the unnested item to preserve visual document order.
+   *
+   * @param {RTEListItemBlock} parentListItem - The list item owning the nestList.
+   * @param {RTEListBlock} target - The list being removed (used as the reference point).
+   * @returns {RTEListBlock[]} The trailing nestList entries (already removed from parentListItem).
+   */
+  collectTrailingNestLists(parentListItem, target) {
+    var _a;
+    const nestLists = (_a = parentListItem.nestList) !== null && _a !== void 0 ? _a : [];
+    const targetIndex = nestLists.indexOf(target);
+    if (targetIndex < 0 || targetIndex >= nestLists.length - 1) {
+      return [];
+    }
+    const trailing = nestLists.slice(targetIndex + 1);
+    // Keep only entries up to and including target (target will be removed separately).
+    parentListItem.apply(new ReplaceNestListAction(nestLists.slice(0, targetIndex + 1)));
+    return trailing;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.js

@@ -16,6 +16,8 @@ export var ModifyContentActionType;
   ModifyContentActionType["LINE_BREAK_MULTIPLE_BLOCKS"] = "LINE_BREAK_MULTIPLE_BLOCKS";
   ModifyContentActionType["TRANSFORM_LIST_BLOCK"] = "TRANSFORM_LIST_BLOCK";
   ModifyContentActionType["TRANSFORM_PARAGRAPH_BLOCK"] = "TRANSFORM_PARAGRAPH_BLOCK";
+  ModifyContentActionType["NEST_LIST_ITEMS"] = "NEST_LIST_ITEMS";
+  ModifyContentActionType["UNNEST_LIST_ITEMS"] = "UNNEST_LIST_ITEMS";
   ModifyContentActionType["DELETE_BLOCK_CONTENT"] = "DELETE_BLOCK_CONTENT";
   ModifyContentActionType["INSERT_IMAGE_TO_BLOCK"] = "INSERT_IMAGE_TO_BLOCK";
   ModifyContentActionType["UPDATE_IMAGE_NODE_URL"] = "UPDATE_IMAGE_NODE_URL";

package/dist/collection/components/vega-rich-text-editor/dto/actions/nest-list-items-action.js

@@ -0,0 +1,12 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to nest the selected list items under the previous sibling.
+ */
+export class NestListItemsAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.type = ModifyContentActionType.NEST_LIST_ITEMS;
+    this.isFlushable = true;
+    this.selectedBlocks = selectedBlocks;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/unnest-list-items-action.js

@@ -0,0 +1,12 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to promote the selected nested list items one level up.
+ */
+export class UnnestListItemsAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.type = ModifyContentActionType.UNNEST_LIST_ITEMS;
+    this.isFlushable = true;
+    this.selectedBlocks = selectedBlocks;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/list-annotation.js

@@ -18,6 +18,18 @@ export class ListAnnotation extends BlockAnnotation {
       marginLeft: '16px',
     };
   }
+  /**
+   * Get the default standalone styles for a list block's item marker
+   * (`li::marker`). Capping the marker font-size keeps bullets/numbers
+   * at a normal size when list items are styled as title/subtitle.
+   *
+   * @returns {AnnotationStyle} The default marker styles.
+   */
+  static getDefaultMarkerStyles() {
+    return {
+      fontSize: '16px',
+    };
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/components/vega-rich-text-editor/dto/blocks/list-block.js

@@ -5,6 +5,8 @@ import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action
 import { ListTransformToListStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy';
 import { ListTransformToParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy';
 import { ListInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/list-insert-image-strategy';
+import { ListNestItemsStrategy } from '../action-handle-strategies/modify-content-strategies/list-nest-items-strategy';
+import { ListUnnestItemsStrategy } from '../action-handle-strategies/modify-content-strategies/list-unnest-items-strategy';
 import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { ListAnnotation } from '../annotations/list-annotation';
 import { isNonNullable } from '../../../../types/type-guard';
@@ -12,7 +14,12 @@ import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annot
 import { CustomClassAnnotation } from '../annotations/custom-class-annotation';
 import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
 /**
- * List block
+ * List block.
+ *
+ * Bidirectional nesting contract:
+ * - Every child list item must have item.parent === this list block.
+ * - If this list block is nested, its parent must be a list item and that
+ *   list item keeps this block in listItem.nestList.
  */
 export class RTEListBlock extends RTEBlock {
   constructor(id, type, options) {
@@ -126,5 +133,7 @@ export class RTEListBlock extends RTEBlock {
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.NEST_LIST_ITEMS, RTEListBlock.name, new ListNestItemsStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UNNEST_LIST_ITEMS, RTEListBlock.name, new ListUnnestItemsStrategy());
 })();
 RTEListBlock.dtoName = 'RTEListBlock';

package/dist/collection/components/vega-rich-text-editor/dto/blocks/list-item-block.js

@@ -19,7 +19,11 @@ import { BlockUpdateTextStyleStrategy } from '../action-handle-strategies/apply-
 import { HorizontalAlignmentAnnotationAction } from '../actions/horizontal-alignment-annotation-action';
 import { BlockUpdateHorizontalAlignmentStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-horizontal-alignment-strategy';
 /**
- * List item block
+ * List item block.
+ *
+ * Bidirectional nesting contract:
+ * - nestList stores nested list blocks owned by this list item.
+ * - Every nested list block must have listBlock.parent === this list item.
  */
 export class RTEListItemBlock extends RTETextBlock {
   constructor(id, nestList, options) {
@@ -46,7 +50,7 @@ export class RTEListItemBlock extends RTETextBlock {
     listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock, options));
     if (block.children) {
       listItemBlock.nestList = block.children.map((child) => {
-        const listBlock = RTEListBlock.from(child);
+        const listBlock = RTEListBlock.from(child, options);
         listBlock.parent = listItemBlock;
         return listBlock;
       });
@@ -73,8 +77,12 @@ export class RTEListItemBlock extends RTETextBlock {
    * @inheritDoc
    */
   toHtml(options) {
+    var _a;
     const attrStr = super.generateAttributeString(options);
-    return [`<li${attrStr}>`, this.getChildrenHtml(options), `</li>`].join('');
+    const nestListHtml = ((_a = this.nestList) === null || _a === void 0 ? void 0 : _a.length)
+      ? this.nestList.map((list) => list.toHtml(options)).join('')
+      : '';
+    return [`<li${attrStr}>`, this.getChildrenHtml(options), nestListHtml, `</li>`].join('');
   }
   /**
    * @inheritDoc