@globalpayments/vega 2.95.0 → 2.97.0

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

@@ -1,15 +1,47 @@
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Replace list item nest list strategy.
+ *
+ * This is the single write-through point for `nestList` mutations. It automatically
+ * normalizes the incoming array by merging adjacent lists only when their types
+ * and container annotations match. Styled list boundaries remain independent.
  */
-export class ListItemReplaceNestListStrategy extends ActionHandleStrategy {
+export class ListItemReplaceNestListStrategy extends ListAnnotationStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
-    action.newList.forEach((listBlock) => {
+    const normalized = this.mergeAdjacentSameType(action.newList);
+    normalized.forEach((listBlock) => {
       listBlock.parent = target;
     });
-    target.nestList = action.newList;
+    target.nestList = normalized;
+  }
+  /**
+   * Merge adjacent entries that share the same list type and annotations.
+   * This is an idempotent O(n) pass — calling it on an already-normalized array is a no-op.
+   *
+   * @param {RTEListBlock[]} lists - The nest list array to normalize.
+   * @returns {RTEListBlock[]} A new array with adjacent same-type entries merged.
+   */
+  mergeAdjacentSameType(lists) {
+    if (lists.length <= 1) {
+      return lists;
+    }
+    const merged = [lists[0]];
+    for (let i = 1; i < lists.length; i++) {
+      const prev = merged[merged.length - 1];
+      const current = lists[i];
+      if (prev.type === current.type && this.haveSameListAnnotations(prev, current)) {
+        current.children.forEach((item) => {
+          item.parent = prev;
+        });
+        prev.children = prev.children.concat(current.children);
+      }
+      else {
+        merged.push(current);
+      }
+    }
+    return merged;
   }
 }

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

@@ -0,0 +1,27 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Shared base strategy for list-item operations that require ordered contiguous
+ * item selection within the same target list.
+ */
+export class AbstractListItemsStrategy extends ActionHandleStrategy {
+  /**
+   * Returns selected list items ordered by their position in target and validated
+   * as a contiguous range. Returns an empty array when selection is invalid.
+   *
+   * @param {RTEListBlock} target - The target list block containing selected items.
+   * @param {RTEListItemBlock[]} selectedBlocks - Selected list items from action payload.
+   * @returns {RTEListItemBlock[]} Ordered contiguous selected items, or empty array.
+   */
+  getOrderedContiguousItems(target, selectedBlocks) {
+    const orderedItems = [...selectedBlocks].sort((a, b) => target.children.indexOf(a) - target.children.indexOf(b));
+    const startIndex = target.children.indexOf(orderedItems[0]);
+    if (startIndex < 0) {
+      return [];
+    }
+    return target.children
+      .slice(startIndex, startIndex + orderedItems.length)
+      .every((item, index) => item === orderedItems[index])
+      ? orderedItems
+      : [];
+  }
+}

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

@@ -0,0 +1,74 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { AbstractListItemsStrategy } from './list-items-strategy.abstract';
+/**
+ * Move selected list items into a nested list under the previous sibling.
+ */
+export class ListNestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a, _b;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    if (!selectedItems.length) {
+      return;
+    }
+    const startIndex = target.children.indexOf(selectedItems[0]);
+    if (startIndex <= 0) {
+      return;
+    }
+    const previousSibling = target.children[startIndex - 1];
+    const selectedItemSet = new Set(selectedItems);
+    // Tab behavior intentionally keeps using the last nested list entry if present,
+    // even when mixed nested-list types exist, to preserve current behavior.
+    // This also matches the behavior of other rich text editors, especially CKEditor.
+    let nestedList = (_a = previousSibling.nestList) === null || _a === void 0 ? void 0 : _a[previousSibling.nestList.length - 1];
+    if (!nestedList) {
+      nestedList = new RTEListBlock(generateUUID(), target.type);
+      previousSibling.apply(new ReplaceNestListAction([...((_b = previousSibling.nestList) !== null && _b !== void 0 ? _b : []), nestedList]));
+    }
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    nestedList.children = nestedList.children.concat(selectedItems);
+    selectedItems.forEach((item) => {
+      var _a;
+      item.parent = nestedList;
+      if ((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length) {
+        this.unifyDescendantNestLists(item, item.nestList[0].type);
+      }
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+  }
+  /**
+   * Recursively unify all nestLists of a list item (and its descendants) to the given type.
+   * Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy
+   * when ReplaceNestListAction is applied, so this method only needs to set the type.
+   *
+   * @param {RTEListItemBlock} item - The list item whose descendants should be normalized.
+   * @param {RTEListBlock['type']} targetType - The target list type used for normalization.
+   */
+  unifyDescendantNestLists(item, targetType) {
+    var _a;
+    if (!((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      return;
+    }
+    let typeChanged = false;
+    for (const list of item.nestList) {
+      if (list.type !== targetType) {
+        list.type = targetType;
+        typeChanged = true;
+      }
+      // Recursively unify children
+      for (const child of list.children) {
+        this.unifyDescendantNestLists(child, targetType);
+      }
+    }
+    // If any type was changed, re-apply through ReplaceNestListAction so that the
+    // centralized normalize in ListItemReplaceNestListStrategy merges adjacent same-type entries.
+    if (typeChanged) {
+      item.apply(new ReplaceNestListAction([...item.nestList]));
+    }
+  }
+}

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