@globalpayments/vega 2.38.0 → 2.40.0

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

@@ -1,14 +1,14 @@
 import { RTEBlock } from './block.abstract';
 import { RTEListItemBlock } from './list-item-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { generateUUID } from '../../../../utils/misc';
-import { RTETextBlock } from './text-block';
-import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { SyncUpSelectionAction } from '../actions/sync-up-selection-action';
-import { RemoveNestListAction } from '../actions/remove-nest-list-action';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { BlockInsertBlocksBeforeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy';
+import { BlockInsertBlocksAfterStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy';
+import { BlockAppendBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
+import { ListRemoveListItemStrategy } from '../action-handle-strategies/modify-content-strategies/list-remove-list-item-strategy';
+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';
 /**
  * List block
  */
@@ -53,151 +53,13 @@ export class RTEListBlock extends RTEBlock {
   getLastNode() {
     return this.blocks[this.blocks.length - 1].getLastNode();
   }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListItemBlock(action.entityToBeRemoved);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_AFTER:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          action.referBlock,
-          ...action.blocksToBeInserted,
-        ]);
-        break;
-      case ModifyContentActionType.INSERT_BLOCKS_BEFORE:
-        this.replaceBlockWithBlocks(action.referBlock, [
-          ...action.blocksToBeInserted,
-          action.referBlock,
-        ]);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildBlocks(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.TRANSFORM_LIST_BLOCK:
-        this.convertToList(action);
-        break;
-      case ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK:
-        this.convertToParagraph(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-    }
-  }
-  /**
-   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
-   *
-   * @param {RTEListItemBlock} block - The block that will be covered
-   * @returns {RTETextBlock} Returns a `RTETextBlock`.
-   */
-  toParagraph(block) {
-    const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
-    textBlock.apply(new AppendChildNodesAction(block['nodes']));
-    textBlock['annotationMap'] = block['annotationMap'];
-    return textBlock;
-  }
-  /**
-   * Covert block to List
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToList(action) {
-    const selectedBlocks = action.selectedBlocks;
-    const bulletList = this.parent.createList(action.listType);
-    const isSameList = selectedBlocks.every((block) => block.parent === this);
-    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 AppendChildNodesAction(this.blocks));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      this.parent.apply(new RemoveChildAction(this));
-      selectedBlocks.forEach((block) => block.nodes.map((node) => node.apply(new SyncUpSelectionAction())));
-    }
-    else {
-      const listItems = action.selectedBlocks.map((block) => this.parent.toListItem(block));
-      bulletList.apply(new AppendChildNodesAction(listItems));
-      this.parent.apply(new InsertBlocksAfterAction(this, bulletList));
-      action.selectedBlocks.forEach((block) => {
-        block.parent.apply(new RemoveChildAction(block));
-      });
-      if (this.blocks.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
-  /**
-   * Covert block to paragraph
-   *
-   * @param {TransformListAction} action - Modify action
-   */
-  convertToParagraph(action) {
-    let isSelectedFirstBlock = false;
-    let isSelectedLastBlock = false;
-    const selectedBlocks = action.selectedBlocks;
-    const currentParagraph = selectedBlocks.map((block) => {
-      block.nodes.map((node) => node.apply(new SyncUpSelectionAction()));
-      if (block === this.blocks[0])
-        isSelectedFirstBlock = true;
-      if (block === this.blocks[this.blocks.length - 1])
-        isSelectedLastBlock = true;
-      return this.toParagraph(block);
-    });
-    if (isSelectedFirstBlock) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, ...currentParagraph));
-    }
-    else if (isSelectedLastBlock) {
-      this.parent.apply(new InsertBlocksAfterAction(this, ...currentParagraph));
-    }
-    else {
-      const startIndex = this.blocks.indexOf(selectedBlocks[0]);
-      const lastIndex = this.blocks.indexOf(selectedBlocks[selectedBlocks.length - 1]);
-      const firstBulletList = this.parent.createList(this.type);
-      firstBulletList.apply(new AppendChildNodesAction(this.blocks.slice(0, startIndex)));
-      const lastBulletList = this.parent.createList(this.type);
-      lastBulletList.apply(new AppendChildNodesAction(this.blocks.slice(lastIndex + 1)));
-      this.parent.apply(new InsertBlocksBeforeAction(this, firstBulletList, ...currentParagraph, lastBulletList));
-      this.parent.apply(new RemoveChildAction(this));
-    }
-    selectedBlocks.map((block) => {
-      this.apply(new RemoveChildAction(block));
-    });
-    if (this.blocks.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Inserts an image block into a rich text editor block based on the parent block type.
-   *
-   * @param {InsertImageToBlockAction} action - Modify action
-   */
-  insertImage(action) {
-    const imageBlock = action.imageBlockToBeInserted;
-    if (this.parent['type'] !== 'list-item') {
-      this.parent.apply(new InsertBlocksAfterAction(this, imageBlock));
-    }
-    else {
-      this.parent.apply(action);
-    }
-  }
-  /**
-   * Removes a specified block and handles the removal of nested lists if necessary.
-   *
-   * @param {RTEBlock} blockToBeRemoved - block that will be removed
-   */
-  removeListItemBlock(blockToBeRemoved) {
-    super.removeChildBlock(blockToBeRemoved);
-    if (this.blocks.length === 0 && this.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 (this.parent instanceof RTEListItemBlock) {
-        this.parent.apply(new RemoveNestListAction(this));
-      }
-      else {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-  }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListBlock.name, new ListRemoveListItemStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, RTEListBlock.name, new BlockInsertBlocksBeforeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, RTEListBlock.name, new BlockInsertBlocksAfterStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListBlock.name, new BlockAppendBlocksStrategy());
+  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());
+})();

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

@@ -1,15 +1,24 @@
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { generateUUID } from '../../../../utils/misc';
-import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-action';
 import { RTETextBlock } from './text-block';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
 import { isNonNullable } from '../../../../types/type-guard';
-import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { ListItemDeleteTextContentStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-delete-text-content-strategy';
+import { BlockInsertLineBreakStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy';
+import { BlockInsertLineBreakWithBlocksStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
+import { ListItemRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-remove-node-strategy';
+import { ListItemRemoveNestListStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-remove-nest-list-strategy';
+import { BlockAppendNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
+import { BlockSplitWithTextNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy';
+import { BlockReplaceNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
+import { ListItemReplaceNestListStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-replace-nest-list-strategy';
+import { BlockMergeNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
+import { ListItemInsertNewParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-insert-new-paragraph-strategy';
+import { ListItemInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/list-item-insert-image-strategy';
+import { BlockInsertNodesBeforeNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
 /**
  * List item block
  */
@@ -84,186 +93,26 @@ export class RTEListItemBlock extends RTETextBlock {
     return super.getLastNode();
   }
   /**
-   * Apply a modify action to block
+   * Create a new list item block.
    *
-   * @param {ModifyContentAction} action - Modify action
+   * @returns {RTEListItemBlock} - A list item block.
    */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeListChildNode(action);
-        break;
-      case ModifyContentActionType.DELETE_NEST_LIST:
-        this.removeNestList(action);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildNodes(action.entityToBeAppended);
-        break;
-      case ModifyContentActionType.CLEAR_CHILD_NODES:
-        this.nodes = [];
-        break;
-      case ModifyContentActionType.SPLIT_BLOCK_WITH_NODE:
-        this.splitListItemBlock(action);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.REPLACE_NEST_LIST:
-        this.replaceNestList(action.newList);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleListItemBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK:
-        action.lineBreakNode = this.lineBreakSingleBlock(action.startContainerNode, action.startOffset);
-        break;
-      case ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS:
-        action.lineBreakNode = this.lineBreakMultipleBlocks(action.selectedBlocks);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteListNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.parent.apply(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Remove the list child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeListChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0 && (!this.children || !this.children.length)) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * Remove the nest list
-   *
-   * @param {RemoveNestListAction} action - Modify action
-   */
-  removeNestList(action) {
-    if (this.children) {
-      if (this.children.length > 1) {
-        this.children = this.children.filter((child) => child !== action.nestListBlockToBeRemoved);
-      }
-      else {
-        this.children = undefined;
-      }
-    }
-  }
-  /**
-   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
-   *
-   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
-   */
-  replaceNestList(newList) {
-    newList.forEach((listBlock) => {
-      listBlock.parent = this;
-    });
-    this.children = newList;
-  }
-  /**
-   * Split list item block
-   *
-   * @param {SplitBlockWithNodeAction} action - Modify action
-   */
-  splitListItemBlock(action) {
-    action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-  }
-  /**
-   * Breaks a single list item block at a specific position.
-   *
-   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
-   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
-   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
-   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
-   * caret position if it is neither at the start nor at the end.
-   */
-  breakSingleListItemBlock(splitNode, startOffsetOfNode) {
-    const newListItem = new RTEListItemBlock(generateUUID());
-    const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
-    newListItem.apply(new AppendChildNodesAction([newBreakNode]));
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      return this.breakListItemAtEnd(newListItem);
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newListItem));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newListItem;
-  }
-  /**
-   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
-   *
-   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
-   * @returns {RTEBlock} Returns a `RTEBlock`.
-   */
-  breakListItemAtEnd(newListItem) {
-    const lastItem = this.parent.blocks[this.parent.blocks.length - 1];
-    const currentItemIsEmpty = this.nodes.length === 1 && this.nodes[0].isEmpty();
-    if (this === lastItem && currentItemIsEmpty) {
-      const parentParent = this.parent.parent;
-      if (parentParent['type'] !== 'list-item') {
-        const newParagraph = RTETextBlock.from({
-          id: generateUUID(),
-          type: 'paragraph',
-          nodes: [],
-        });
-        newParagraph.apply(new AppendChildNodesAction(newListItem.nodes));
-        parentParent.apply(new InsertBlocksAfterAction(this.parent, newParagraph));
-        this.parent.apply(new RemoveChildAction(this));
-        return newParagraph;
-      }
-      else {
-        parentParent.parent.apply(new InsertBlocksAfterAction(parentParent, newListItem));
-        this.parent.apply(new RemoveChildAction(this));
-      }
-    }
-    else {
-      this.parent.apply(new InsertBlocksAfterAction(this, newListItem));
-    }
-    return newListItem;
-  }
-  /**
-   * Delete list node content
-   *
-   * @param {DeleteBlockContentAction} action - Modify action
-   */
-  deleteListNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const listBlock = startContainerNode.parentBlock.parent;
-    this.deleteNodeContent(action);
-    if (listBlock.blocks.length === 0) {
-      listBlock.parent.apply(new RemoveChildAction(listBlock));
-    }
-  }
-  /**
-   * Copy the inline style to new node
-   *
-   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
-   * @returns {RTETextNode} Returns a `RTETextNode`.
-   */
-  copyInlineStyleToNewNode(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation doesn't need to inherit
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    return textNode;
+  createNewListItem() {
+    return new RTEListItemBlock(generateUUID());
   }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEListItemBlock.name, new ListItemDeleteTextContentStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new BlockInsertLineBreakStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTEListItemBlock.name, new ListItemRemoveNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name, new ListItemRemoveNestListStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTEListItemBlock.name, new BlockAppendNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name, new BlockSplitWithTextNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name, new BlockReplaceNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name, new ListItemReplaceNestListStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name, new BlockMergeNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEListItemBlock.name, new ListItemInsertNewParagraphStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListItemBlock.name, new ListItemInsertImageStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTEListItemBlock.name, new BlockInsertNodesBeforeNodeStrategy());
+})();