@globalpayments/vega 2.38.0 → 2.40.0

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

@@ -2,23 +2,28 @@ import { RTETextNode } from '../nodes/text-node';
 import { isNonNullable } from '../../../../types/type-guard';
 import { TextStyleAnnotation } from '../annotations/text-style-annotation';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { RemoveChildAction } from '../actions/remove-child-action';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { RTEBlock } from './block.abstract';
-import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { TextStyleAnnotationAction } from '../actions/text-style-annotation-action';
-import { BoldAnnotationAction } from '../actions/bold-annotation-action';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
 import { LinkAnnotationAction } from '../actions/link-annotation-action';
 import { LinkGroupAnnotationAction } from '../actions/link-group-annotation-action';
-import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-action';
 import { generateUUID } from '../../../../utils/misc';
-import { ReplaceChildNodesAction } from '../actions/replace-child-nodes-action';
-import { MergeTwoBlocksNodesAction } from '../actions/merge-two-blocks-nodes-action';
-import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
-import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { UpdateTextAction } from '../actions/update-text-action';
-import { DeleteNodeAnnotationAction } from '../actions/delete-node-annotation-action';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { BlockUpdateTextStyleStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-text-style-strategy';
+import { BlockUpdateLinkGroupStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-link-group-strategy';
+import { BlockRemoveNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-remove-node-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 { BlockMergeNodesStrategy } from '../action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
+import { BlockInsertNewParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-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 { BlockDeleteTextContentStrategy } from '../action-handle-strategies/modify-content-strategies/block-delete-text-content-strategy';
+import { BlockInsertImageIntoTextStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-image-into-text-strategy';
+import { BlockInsertNodesBeforeNodeStrategy } from '../action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
+import { BlockTransformToListStrategy } from '../action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy';
 /**
  * Text block
  */
@@ -135,353 +140,36 @@ export class RTETextBlock extends RTEBlock {
     return this.nodes[this.nodes.length - 1];
   }
   /**
-   * @inheritDoc
-   */
-  doAnnotationActionApply(action) {
-    if (action instanceof TextStyleAnnotationAction) {
-      if (this.type !== 'list-item') {
-        this.type = action.textStyle;
-      }
-      if (action.bold) {
-        this.nodes.forEach((node) => {
-          const boldAnnotationAction = new BoldAnnotationAction(true);
-          boldAnnotationAction.doSplit = false;
-          node.apply(boldAnnotationAction);
-        });
-      }
-      else {
-        this.nodes.forEach((node) => {
-          node.apply(new DeleteNodeAnnotationAction(NodeAnnotationTypeEnum.BOLD));
-        });
-      }
-      return;
-    }
-    if (action instanceof LinkGroupAnnotationAction) {
-      const linkGroupAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
-      if (linkGroupAnnotation) {
-        const linkGroup = linkGroupAnnotation.linkGroups.get(action.groupKey);
-        linkGroupAnnotation.linkGroups.set(action.groupKey, [...linkGroup, ...action.nodes]);
-        this.annotationMap.set(InternalAnnotationTypeEnum.LINK_GROUP, linkGroupAnnotation);
-      }
-      return;
-    }
-  }
-  /**
-   * Apply a modify action to block
-   *
-   * @param {ModifyContentAction} action - Modify action
-   */
-  doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildNode(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:
-        action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
-        break;
-      case ModifyContentActionType.REPLACE_CHILD_NODES:
-        this.nodes = [];
-        this.appendChildNodes(action.newChildNodes);
-        break;
-      case ModifyContentActionType.MERGE_TWO_BLOCKS_NODES:
-        this.mergeTwoBlocksNodes(action.blockNeedToBeMerged);
-        break;
-      case ModifyContentActionType.BREAK_SINGLE_BLOCK:
-        action.newBlock = this.breakSingleTextBlock(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.TRANSFORM_LIST_BLOCK:
-        this.convertParagraphToList(action);
-        break;
-      case ModifyContentActionType.DELETE_BLOCK_CONTENT:
-        this.deleteNodeContent(action);
-        break;
-      case ModifyContentActionType.INSERT_IMAGE_TO_BLOCK:
-        this.insertImage(action);
-        break;
-      case ModifyContentActionType.INSERT_NODES_BEFORE:
-        this.replaceNodeWithNodes(action.referNode, [
-          ...action.nodesToBeInserted,
-          action.referNode,
-        ]);
-        break;
-    }
-  }
-  /**
-   * Splits a text node at a specified offset within a block of nodes and returns a new block with the split nodes.
-   *
-   * @param {RTETextNode} splitNode - The text node that will be split
-   * @param {number} startOffsetOfNode - The index at which will split the text content of the `splitNode`.
-   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
-   */
-  splitTextNodeBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.apply(new ReplaceChildNodesAction(beforeNodes));
-        const newBlock = this.cloneWithNodes(afterNodes);
-        this.parent.apply(new InsertBlocksAfterAction(this, newBlock));
-        return newBlock;
-      }
-    }
-  }
-  /**
-   * Checks if the caret position is at the start of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtStart(node, startOffset) {
-    return node === this.nodes[0] && startOffset === 0;
-  }
-  /**
-   * Checks if the caret position is at the end of a specified RTETextNode.
-   *
-   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
-   * @param {number} startOffset - The position within the text node where the caret is located.
-   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
-   */
-  isCaretPositionAtEnd(node, startOffset) {
-    const lastNode = this.nodes[this.nodes.length - 1];
-    return node === lastNode && (node.isEmpty() || startOffset === lastNode.text.length);
-  }
-  /**
-   * lineBreakSingleBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakSingleBlock(splitNode, startOffsetOfNode) {
-    if (splitNode) {
-      const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-      const beforeText = splitNode.text.slice(0, startOffsetOfNode);
-      const afterText = splitNode.text.slice(startOffsetOfNode);
-      const nodesSplitIndex = this.nodes.indexOf(splitNode);
-      if (nodesSplitIndex > -1) {
-        const beforeNodes = this.nodes.slice(0, nodesSplitIndex);
-        const afterNodes = this.nodes.slice(nodesSplitIndex + 1);
-        if (beforeText) {
-          beforeNodes.push(splitNode.cloneWithText(beforeText));
-        }
-        if (afterText) {
-          afterNodes.unshift(splitNode.cloneWithText(afterText));
-        }
-        this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-      }
-      return lineBreakNode;
-    }
-  }
-  /**
-   * lineBreakMultipleBlocks
-   *
-   * @param {RTEBlock[]} selectedBlocks -
-   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
-   */
-  lineBreakMultipleBlocks(selectedBlocks) {
-    const beforeNodes = this['nodes'];
-    const lineBreakNode = new RTETextNode(generateUUID(), '\n', this);
-    const afterNodes = this.concatBlocksNodes(selectedBlocks.slice(1));
-    this.mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes);
-    return lineBreakNode;
-  }
-  /**
-   * deleteNodeContent
-   *
-   * @param {DeleteBlockContentAction} action - ModifyContentAction
-   */
-  deleteNodeContent(action) {
-    const startContainerNode = action.startContainerNode;
-    const startOffset = action.startOffset;
-    if (startOffset !== 0 && !startContainerNode.isEmpty()) {
-      const newText = startContainerNode.text.slice(0, startOffset - 1) +
-        startContainerNode.text.slice(startOffset);
-      startContainerNode.apply(new UpdateTextAction(newText));
-      if (newText) {
-        action.previousNode = startContainerNode;
-        return;
-      }
-      else {
-        const previousNode = this.getPreviousNode(startContainerNode);
-        // Remove the last character will not delete paragraph, the paragraph will removed after press delete again
-        if ((previousNode && previousNode.parentBlock === this && previousNode['text'] === '\n') ||
-          this.nodes.length === 1) {
-          action.previousNode = startContainerNode;
-          return;
-        }
-        else {
-          this.apply(new RemoveChildAction(startContainerNode));
-          action.previousNode = previousNode;
-          return;
-        }
-      }
-    }
-    else {
-      let previousNode = this.getPreviousNode(startContainerNode);
-      let nextNode = null;
-      if (this.nodes.length && previousNode && previousNode.parentBlock !== this) {
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        previousNode.parentBlock.apply(new MergeTwoBlocksNodesAction(this));
-      }
-      else {
-        if (this.isContentFirstNode(startContainerNode) && startContainerNode.isEmpty()) {
-          nextNode = this.getNextNode(startContainerNode);
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the first line
-         * \n
-         * test
-         */
-        if (startContainerNode.isEmpty()) {
-          this.apply(new RemoveChildAction(startContainerNode));
-        }
-        /**
-         * Remove line break
-         *
-         * @example caret at the begin of second line
-         * \n
-         * test
-         */
-        if (previousNode instanceof RTETextNode && previousNode.isEmpty()) {
-          const shouldRemoveNode = previousNode;
-          previousNode = this.getPreviousNode(previousNode);
-          shouldRemoveNode.parentBlock.apply(new RemoveChildAction(shouldRemoveNode));
-          if (!previousNode) {
-            nextNode = startContainerNode;
-          }
-        }
-      }
-      //Remove the paragraph block if the content is empty
-      if (this.nodes.length === 0) {
-        this.parent.apply(new RemoveChildAction(this));
-      }
-      if (previousNode) {
-        action.previousNode = previousNode;
-      }
-      else if (nextNode) {
-        action.nextNode = nextNode;
-      }
-    }
-  }
-  /**
-   * Remove the child node
-   *
-   * @param {RemoveChildAction} action - Modify action
-   */
-  removeChildNode(action) {
-    this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
-    if (this.nodes.length === 0) {
-      this.parent.apply(new RemoveChildAction(this));
-    }
-  }
-  /**
-   * mergeLineBreakNodes
+   * Create new empty paragraph.
    *
-   * @param {RTENode[]} beforeNodes -
-   * @param {RTETextNode} lineBreakNode -
-   * @param {RTENode[]} afterNodes -
+   * @returns {RTETextBlock} Paragraph.
    */
-  mergeLineBreakNodes(beforeNodes, lineBreakNode, afterNodes) {
-    if (afterNodes.length === 0 || (afterNodes[0] && afterNodes[0].text === '')) {
-      afterNodes.push(new RTETextNode(generateUUID(), '\n', this, beforeNodes[beforeNodes.length - 1] && beforeNodes[beforeNodes.length - 1].annotationMap));
-    }
-    this.apply(new ReplaceChildNodesAction([...beforeNodes, lineBreakNode, ...afterNodes]));
-  }
-  /**
-   * breakSingleTextBlock
-   *
-   * @param {RTETextNode} splitNode -
-   * @param {number} startOffsetOfNode -
-   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
-   */
-  breakSingleTextBlock(splitNode, startOffsetOfNode) {
-    const newParagraph = this.copyInlineStyleToNewParagraph(splitNode);
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newParagraph));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newParagraph));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      return splitBlockAction.newBlock;
-    }
-    return newParagraph;
+  createNewParagraph() {
+    return new RTETextBlock(generateUUID(), 'paragraph');
   }
   /**
-   * convertParagraphToList
-   *
-   * @param {TransformListAction} action - ModifyContentAction
-   */
-  convertParagraphToList(action) {
-    const bulletList = this.parent.createList(action.listType);
-    const listItems = action.selectedBlocks.map((node) => this.parent.toListItem(node));
-    bulletList.apply(new AppendChildNodesAction(listItems));
-    this.parent.apply(new InsertBlocksAfterAction(action.selectedBlocks[0], bulletList));
-    action.selectedBlocks.forEach((node) => {
-      node.parent.apply(new RemoveChildAction(node));
-    });
-  }
-  /**
-   * insertImage
-   *
-   * @param {InsertImageToBlockAction} action - ModifyContentAction
+   * @inheritDoc
    */
-  insertImage(action) {
-    const splitNode = action.splitPointNode;
-    const startOffsetOfNode = action.startOffsetOfNode;
-    const newImageBlock = action.imageBlockToBeInserted;
-    if (this.isCaretPositionAtEnd(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
-    }
-    else if (this.isCaretPositionAtStart(splitNode, startOffsetOfNode)) {
-      this.parent.apply(new InsertBlocksBeforeAction(this, newImageBlock));
-    }
-    else {
-      const splitBlockAction = new SplitBlockWithNodeAction(splitNode, startOffsetOfNode);
-      this.apply(splitBlockAction);
-      this.parent.apply(new InsertBlocksAfterAction(this, newImageBlock));
+  doAnnotationActionApply(action) {
+    const strategy = ActionHandleStrategyRegistry.get(action.constructor.name, RTETextBlock.name);
+    if (strategy) {
+      strategy.execute(action, this);
     }
   }
-  /**
-   * copyInlineStyleToNewParagraph
-   *
-   * @param {RTETextNode} needCopedNode -
-   * @returns {RTETextBlock} RTETextBlock
-   */
-  copyInlineStyleToNewParagraph(needCopedNode) {
-    const textNode = needCopedNode.cloneWithText('');
-    // The link annotation don't need inherited
-    textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    const newParagraph = new RTETextBlock(generateUUID(), 'paragraph');
-    newParagraph.apply(new AppendChildNodesAction([textNode]));
-    return newParagraph;
-  }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(TextStyleAnnotationAction.name, RTETextBlock.name, new BlockUpdateTextStyleStrategy());
+  ActionHandleStrategyRegistry.register(LinkGroupAnnotationAction.name, RTETextBlock.name, new BlockUpdateLinkGroupStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, RTETextBlock.name, new BlockRemoveNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, RTETextBlock.name, new BlockAppendNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTETextBlock.name, new BlockSplitWithTextNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_CHILD_NODES, RTETextBlock.name, new BlockReplaceNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTETextBlock.name, new BlockMergeNodesStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTETextBlock.name, new BlockInsertNewParagraphStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTETextBlock.name, new BlockInsertLineBreakStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTETextBlock.name, new BlockInsertLineBreakWithBlocksStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTETextBlock.name, new BlockDeleteTextContentStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTETextBlock.name, new BlockInsertImageIntoTextStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_NODES_BEFORE, RTETextBlock.name, new BlockInsertNodesBeforeNodeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTETextBlock.name, new BlockTransformToListStrategy());
+})();

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -4,15 +4,18 @@ import { RTETextBlock } from './blocks/text-block';
 import { ModifyContentActionType } from './actions/modify-content-action.abstract';
 import { AppendChildNodesAction } from './actions/append-child-nodes-action';
 import { generateUUID } from '../../../utils/misc';
-import { BlockBaseOperator } from './helper/block-base-operator';
 import { RTEListItemBlock } from './blocks/list-item-block';
 import { SyncUpSelectionAction } from './actions/sync-up-selection-action';
+import { ActionHandleStrategyRegistry } from './action-handle-strategies/action-handle-strategy-registry';
+import { BlockRemoveChildBlockStrategy } from './action-handle-strategies/modify-content-strategies/block-remove-child-block-strategy';
+import { BlockAppendBlocksStrategy } from './action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
+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';
 /**
  * Class representing the content state of the rich text editor.
  */
-export class VegaRTEContent extends BlockBaseOperator {
+export class VegaRTEContent {
   constructor(blocks) {
-    super();
     blocks.forEach((block) => {
       block.parent = this;
     });
@@ -89,26 +92,7 @@ export class VegaRTEContent extends BlockBaseOperator {
    * @param {ModifyContentAction} action - Modify content action
    */
   apply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.DELETE_CHILD:
-        this.removeChildBlock(action.entityToBeRemoved);
-        break;
-      case ModifyContentActionType.APPEND_CHILD_NODES:
-        this.appendChildBlocks(action.entityToBeAppended);
-        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;
-    }
+    ActionHandleStrategyRegistry.executeTheStrategy(action, this);
   }
   /**
    * Convert text to list.
@@ -133,3 +117,9 @@ export class VegaRTEContent extends BlockBaseOperator {
     return new RTEListBlock(generateUUID(), type);
   }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.DELETE_CHILD, VegaRTEContent.name, new BlockRemoveChildBlockStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.APPEND_CHILD_NODES, VegaRTEContent.name, new BlockAppendBlocksStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_BEFORE, VegaRTEContent.name, new BlockInsertBlocksBeforeStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_BLOCKS_AFTER, VegaRTEContent.name, new BlockInsertBlocksAfterStrategy());
+})();

package/dist/collection/components/vega-rich-text-editor/dto/nodes/image-node.js

@@ -1,8 +1,12 @@
 import { NodeTypeEnum, RTENode } from './node.abstract';
 import { ImageAnnotation } from '../annotations/image-annotation';
-import { methodPlaceholder } from 'vega-slimmer/core';
+import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
 import { isNonNullable } from '../../../../types/type-guard';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { ImageSetAnnotationMapStrategy } from '../action-handle-strategies/apply-annotation-strategies/image-set-annotation-map-strategy';
+import { ImageUpdateUrlStrategy } from '../action-handle-strategies/modify-content-strategies/image-update-url-strategy';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
 /**
  * Image node
  */
@@ -52,15 +56,19 @@ export class RTEImageNode extends RTENode {
    * @inheritDoc
    */
   doAnnotationActionApply(action) {
-    const annotation = action.toAnnotation();
-    this.annotationMap.set(annotation.type, annotation);
+    const strategy = ActionHandleStrategyRegistry.get(AnnotationAction.name, RTEImageNode.name);
+    if (strategy) {
+      strategy.execute(action, this);
+    }
   }
-  // placeholder method
-  /* istanbul ignore next */
   /**
    * @inheritDoc
    */
   doModifyActionApply(action) {
-    methodPlaceholder(action);
+    ActionHandleStrategyRegistry.executeTheStrategy(action, this);
   }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_IMAGE_NODE_URL, RTEImageNode.name, new ImageUpdateUrlStrategy());
+  ActionHandleStrategyRegistry.register(AnnotationAction.name, RTEImageNode.name, new ImageSetAnnotationMapStrategy());
+})();