@heartlandone/vega 2.94.0 → 2.96.0

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

@@ -1,5 +1,9 @@
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
 import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RemoveChildrenStrategy } from './remove-children-strategy';
 /**
  * List remove list item strategy.
@@ -12,16 +16,92 @@ export class ListRemoveListItemStrategy extends RemoveChildrenStrategy {
    * @param {RTEListBlock} target - The list block.
    */
   handleAction(action, target) {
+    var _a, _b;
+    const removingListItem = action.entityToBeRemoved instanceof RTEListItemBlock ? action.entityToBeRemoved : null;
+    const removingIndex = removingListItem ? target.children.indexOf(removingListItem) : -1;
+    if (((_a = removingListItem === null || removingListItem === void 0 ? void 0 : removingListItem.nestList) === null || _a === void 0 ? void 0 : _a.length) && removingIndex >= 0) {
+      this.promoteNestListsToUpperLevel(removingListItem, target, removingIndex);
+    }
     super.handleAction(action, target);
     const parent = target.parent;
     if (target.children.length === 0 && parent) {
       // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
       if (parent['type'] === 'list-item') {
-        parent.apply(new RemoveNestListAction(target));
+        const parentListItem = parent;
+        if ((_b = parentListItem.nestList) === null || _b === void 0 ? void 0 : _b.includes(target)) {
+          parentListItem.apply(new RemoveNestListAction(target));
+        }
       }
       else {
         parent.apply(new RemoveChildrenAction(target));
       }
     }
   }
+  /**
+   * Promote nested lists of the list item being removed by one level.
+   *
+   * Same-type nested lists are flattened into the current (target) list to avoid
+   * creating redundant list wrappers. Different-type nested lists stay nested under
+   * the parent list item as siblings of the target list, positioned relative to the
+   * target so document order is preserved. When the parent is the root content, the
+   * different-type lists are inserted right after the target list instead.
+   *
+   * @param {RTEListItemBlock} removingListItem - The list item being removed.
+   * @param {RTEListBlock} target - The list currently containing the item.
+   * @param {number} removingIndex - The original index of the removing item.
+   */
+  promoteNestListsToUpperLevel(removingListItem, target, removingIndex) {
+    var _a, _b;
+    const promotedLists = [...((_a = removingListItem.nestList) !== null && _a !== void 0 ? _a : [])];
+    let insertionIndex = removingIndex + 1;
+    const differentTypeLists = [];
+    promotedLists.forEach((listBlock) => {
+      if (listBlock.type === target.type) {
+        const promotedItems = [...listBlock.children];
+        if (promotedItems.length > 0) {
+          promotedItems.forEach((item) => {
+            item.parent = target;
+          });
+          target.children.splice(insertionIndex, 0, ...promotedItems);
+          insertionIndex += promotedItems.length;
+        }
+      }
+      else {
+        differentTypeLists.push(listBlock);
+      }
+    });
+    const parent = target.parent;
+    if (differentTypeLists.length > 0 && parent instanceof RTEListItemBlock) {
+      // Different-type promoted lists stay nested under the parent item, as siblings
+      // of the target list. When the removed item was merged into the parent, its
+      // own nested lists follow it up one level and belong to the parent item — not
+      // flattened into the grandparent list. Position them relative to the target so
+      // document order is preserved.
+      const currentNestLists = [...((_b = parent.nestList) !== null && _b !== void 0 ? _b : [])];
+      const targetIndex = currentNestLists.indexOf(target);
+      if (targetIndex >= 0) {
+        // When removing the first item, its nested lists were visually above the
+        // remaining items, so they must be placed before the target list to
+        // preserve document order.
+        const insertAt = removingIndex === 0 ? targetIndex : targetIndex + 1;
+        currentNestLists.splice(insertAt, 0, ...differentTypeLists);
+      }
+      else {
+        currentNestLists.push(...differentTypeLists);
+      }
+      parent.apply(new ReplaceNestListAction(currentNestLists));
+    }
+    else if (differentTypeLists.length > 0) {
+      // Mirror the nested-parent ordering rule: when removing the first item,
+      // its nested lists were visually above the remaining items, so insert
+      // before the target to preserve document order.
+      if (removingIndex === 0) {
+        parent.apply(new InsertChildrenBeforeAction(target, ...differentTypeLists));
+      }
+      else {
+        parent.apply(new InsertChildrenAfterAction(target, ...differentTypeLists));
+      }
+    }
+    removingListItem.apply(new ReplaceNestListAction([]));
+  }
 }

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

@@ -0,0 +1,30 @@
+/**
+ * Normalize a mixed paragraph/list selection before rebuilding it as a list.
+ *
+ * Selected list items whose owning ancestor item is also selected remain inside
+ * that ancestor's nestList instead of being emitted again as flattened siblings.
+ * Their immediate list type is still updated because the nested item was part of
+ * the toolbar selection.
+ *
+ * @param {RTEBlock[]} selectedBlocks - Blocks selected by the toolbar action.
+ * @param {ListType} listType - Target list type.
+ * @returns {RTEBlock[]} Top-level selected blocks to emit into the rebuilt list.
+ */
+export function normalizeMixedListSelection(selectedBlocks, listType) {
+  const selectedListItems = new Set(selectedBlocks.filter((block) => block.dtoName === 'RTEListItemBlock'));
+  return selectedBlocks.filter((block) => {
+    if (!(block.dtoName === 'RTEListItemBlock')) {
+      return true;
+    }
+    let parentList = block.parent;
+    while (parentList.parent && parentList.parent.dtoName === 'RTEListItemBlock') {
+      const ownerItem = parentList.parent;
+      if (selectedListItems.has(ownerItem)) {
+        block.parent.type = listType;
+        return false;
+      }
+      parentList = ownerItem.parent;
+    }
+    return true;
+  });
+}

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;
+  }
 }