@globalpayments/vega 2.38.0 → 2.40.0

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

@@ -1,5 +1,6 @@
 import { NodeTypeEnum, RTENode } from './node.abstract';
-import { NodeAnnotation, NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
+import { NodeAnnotation } from '../annotations/node-annotation.abstract';
+import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { TextSplittableAction } from '../actions/splittable-action.abstract';
 import { SelectionRangeAnnotation } from '../annotations/selection-range-annotation';
 import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
@@ -10,22 +11,21 @@ import { UnderlineAnnotation } from '../annotations/underline-annotation';
 import { ItalicAnnotation } from '../annotations/italic-annotation';
 import { BoldAnnotation } from '../annotations/bold-annotation';
 import { isNonNullable } from '../../../../types/type-guard';
-import { ClearFormattingAnnotation } from '../annotations/clear-formatting-annotation';
 import { CodeAnnotation } from '../annotations/code-annotation';
 import { TextColorAnnotation } from '../annotations/text-color-annotation';
 import { LinkAnnotation } from '../annotations/link-annotation';
-import { LinkAnnotationAction } from '../actions/link-annotation-action';
-import { CodeAnnotationAction } from '../actions/code-annotation-action';
-import { ClearFormattingAnnotationAction } from '../actions/clear-formatting-annotation-action';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
-import { UpdateTextAction } from '../actions/update-text-action';
 import { LinkGroupAnnotationAction } from '../actions/link-group-annotation-action';
 import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import { VegaInternalRichTextEditorSelectionRangeChange } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
 import ChangeManager from '../../../../helpers/change-manager/change-manager';
 import { ZERO_WIDTH_SPACE } from '../../constants/constant';
 import { SyncUpSelectionAction } from '../actions/sync-up-selection-action';
-import { DeleteNodeAnnotationAction } from '../actions/delete-node-annotation-action';
+import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action-handle-strategy-registry';
+import { NodeUpdateTextStrategy } from '../action-handle-strategies/modify-content-strategies/node-update-text-strategy';
+import { NodeReplaceSelectedTextStrategy } from '../action-handle-strategies/modify-content-strategies/node-replace-selected-text-strategy';
+import { NodeSplitTextStrategy } from '../action-handle-strategies/apply-annotation-strategies/node-split-text-strategy';
+import { NodeUpdateAnnotationMapStrategy } from '../action-handle-strategies/apply-annotation-strategies/node-update-annotation-map-strategy';
 /**
  * Text node
  */
@@ -118,23 +118,13 @@ export class RTETextNode extends RTENode {
   doAnnotationActionApply(action) {
     const selectionRangeAnnotation = this.getAnnotationByType(InternalAnnotationTypeEnum.SELECTION_RANGE);
     if (action instanceof TextSplittableAction && action.doSplit && selectionRangeAnnotation) {
-      const { startContainer, endContainer, startOffset, endOffset } = selectionRangeAnnotation.range;
-      const noTextRangeSelected = startContainer === endContainer && startOffset === endOffset;
-      this.parentBlock.nodes = this.parentBlock.nodes.flatMap((item) => {
-        if (item.id === this.id) {
-          if (noTextRangeSelected) {
-            return this.insertNewNode(startOffset, action);
-          }
-          if (this.shouldSplitSelection(selectionRangeAnnotation.range)) {
-            return this.splitTextNode(action, selectionRangeAnnotation.range);
-          }
-          else {
-            this.applyActionToNode(this, action);
-            return this;
-          }
+      const splitStrategy = ActionHandleStrategyRegistry.get(TextSplittableAction.name, RTETextNode.name);
+      if (splitStrategy) {
+        const newNode = splitStrategy.execute(action, this);
+        if (newNode) {
+          this.applyActionToNode(newNode, action);
         }
-        return item;
-      });
+      }
     }
     else {
       this.applyActionToNode(this, action);
@@ -145,61 +135,7 @@ export class RTETextNode extends RTENode {
    * @inheritDoc
    */
   doModifyActionApply(action) {
-    switch (action.type) {
-      case ModifyContentActionType.UPDATE_TEXT:
-        this.updateText(action.newTextContent);
-        break;
-      case ModifyContentActionType.REPLACE_SELECTED_TEXT:
-        this.replaceSelectedText(action.textToBeInsert, action.currentRange);
-        break;
-    }
-  }
-  /**
-   * Split text node with range
-   *
-   * @param {TextSplittableAction} action - Annotation action
-   * @param {Range} range - Selection range
-   * @returns {RTETextNode[] | this} RTETextNode array
-   */
-  splitTextNode(action, range) {
-    const { startContainer, endContainer, startOffset } = range;
-    const startNode = startContainer.parentElement;
-    const endNode = endContainer.parentElement;
-    /**
-     * Split the text from the start offset to the end offset
-     *
-     * @param {string} text - The text string
-     * @param {number} startOffset - The start offset position
-     * @param {number} endOffset - The end offset position
-     * @returns {RTETextNode[]} - The split text node array
-     */
-    const splitText = (text, startOffset, endOffset) => {
-      const beforeText = text.substring(0, startOffset);
-      const selectedText = text.substring(startOffset, endOffset);
-      const afterText = text.substring(endOffset);
-      return [
-        this.cloneWithText(beforeText),
-        this.cloneWithText(selectedText),
-        this.cloneWithText(afterText),
-      ];
-    };
-    const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
-    const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
-    if (startItemDto && startItemDto.id === this.id) {
-      const endOffset = startContainer === endContainer ? range.endOffset : this.text.length;
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, startOffset, endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else if (endItemDto && endItemDto.id === this.id) {
-      const [beforeNode, selectedNode, afterNode] = splitText(this.text, 0, range.endOffset);
-      this.applyActionToNode(selectedNode, action);
-      return [beforeNode, selectedNode, afterNode].filter((node) => !!node.text);
-    }
-    else {
-      this.applyActionToNode(this, action);
-      return this;
-    }
+    ActionHandleStrategyRegistry.executeTheStrategy(action, this);
   }
   /**
    * Apply action to node
@@ -217,89 +153,12 @@ export class RTETextNode extends RTENode {
     if (!(annotation instanceof SelectionRangeAnnotation)) {
       this.syncUpSelectedNodes(node);
     }
-    if (action instanceof DeleteNodeAnnotationAction) {
-      this.annotationMap.delete(action.annotationType);
-      return;
-    }
-    if (annotation instanceof ClearFormattingAnnotation) {
-      annotation.items.forEach((item) => {
-        node.deleteAnnotationByType(item);
-      });
-      return;
-    }
-    if (annotation instanceof NodeAnnotation || annotation instanceof SelectionRangeAnnotation) {
-      if (action instanceof LinkAnnotationAction) {
-        if (isNonNullable(action.newText)) {
-          node.text = action.newText;
-        }
-        this.parentBlock.apply(new LinkGroupAnnotationAction(action.link.groupKey, [node]));
-      }
-      if (action instanceof CodeAnnotationAction) {
-        this.applyActionToNode(node, new ClearFormattingAnnotationAction());
-      }
-      node.annotationMap.set(annotation.type, annotation);
+    const updateAnnotationMapStrategy = ActionHandleStrategyRegistry.get(AnnotationAction.name, RTETextNode.name);
+    if (updateAnnotationMapStrategy) {
+      updateAnnotationMapStrategy.execute(action, node);
       return;
     }
   }
-  /**
-   * Replaces the selected text within a given range with a new text in a TypeScript class.
-   *
-   * @param {string} text - The new text that will replace the currently selected text within the specified range.
-   * @param {RTERange} currentRange - A range of text within a Rich Text Editor (RTE).
-   */
-  replaceSelectedText(text, currentRange) {
-    if (currentRange && currentRange.startContainer && currentRange.endContainer) {
-      const { startContainer, endContainer, startOffset, endOffset } = currentRange;
-      const startNode = startContainer.parentElement;
-      const endNode = endContainer.parentElement;
-      const startItemDto = startNode && stateEntityRenderingRegistry.getEntityByDOM(startNode);
-      const endItemDto = endNode && stateEntityRenderingRegistry.getEntityByDOM(endNode);
-      let startIndex = 0, endIndex = this.text.length;
-      if (startItemDto && startItemDto === this) {
-        startIndex = startOffset;
-        endIndex = startContainer === endContainer ? endOffset : endIndex;
-      }
-      else if (endItemDto && endItemDto === this) {
-        endIndex = endOffset;
-      }
-      this.apply(new UpdateTextAction(this.text.slice(0, startIndex) + text + this.text.slice(endIndex)));
-    }
-  }
-  /**
-   * Updates the text content of a node and unlink the node if it is a link node and the text is deleted.
-   *
-   * @param {string} newText - The new text string
-   */
-  updateText(newText) {
-    this.text = newText;
-    // The link node should unlink when delete all text
-    if (!this.text && this.isLinkNode()) {
-      this.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
-    }
-  }
-  /**
-   * Checks if a node has an annotation with the key 'LINK'.
-   *
-   * @returns {boolean} A boolean value indicating whether the `annotationMap` has a key 'LINK'.
-   */
-  isLinkNode() {
-    return this.annotationMap.has('LINK');
-  }
-  /**
-   * Whether a given range should be split based on various conditions within the range.
-   *
-   * @param {Range} range - Selection range
-   * @returns {boolean} Returns a boolean value indicating whether the
-   * selection range should be split.
-   */
-  shouldSplitSelection(range) {
-    const { startContainer, endContainer, startOffset, endOffset } = range;
-    const isCrossNode = startContainer !== endContainer;
-    const isPartialStart = startOffset > 0;
-    const isPartialEnd = endOffset < (endContainer.textContent ? endContainer.textContent.length : 0);
-    const isPartialSelection = isPartialStart || isPartialEnd;
-    return isCrossNode || isPartialSelection;
-  }
   /**
    * Sync up the selected node by change manager
    *
@@ -314,28 +173,10 @@ export class RTETextNode extends RTENode {
       }
     }
   }
-  /**
-   * Insert the new node at the start offset
-   *
-   * @param {number} startOffset - The start position offset
-   * @param {AnnotationAction} action - AnnotationAction
-   * @returns {RTETextNode[]} - RTETextNode array
-   */
-  insertNewNode(startOffset, action) {
-    if (startOffset === 0) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [newNode, this];
-    }
-    if (startOffset === this.text.length) {
-      const newNode = this.cloneWithText('');
-      this.applyActionToNode(newNode, action);
-      return [this, newNode];
-    }
-    const beforeNode = this.cloneWithText(this.text.substring(0, startOffset));
-    const newNode = this.cloneWithText('');
-    const afterNode = this.cloneWithText(this.text.substring(startOffset));
-    this.applyActionToNode(newNode, action);
-    return [beforeNode, newNode, afterNode];
-  }
 }
+(() => {
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UPDATE_TEXT, RTETextNode.name, new NodeUpdateTextStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.REPLACE_SELECTED_TEXT, RTETextNode.name, new NodeReplaceSelectedTextStrategy());
+  ActionHandleStrategyRegistry.register(TextSplittableAction.name, RTETextNode.name, new NodeSplitTextStrategy());
+  ActionHandleStrategyRegistry.register(AnnotationAction.name, RTETextNode.name, new NodeUpdateAnnotationMapStrategy());
+})();

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/image-toolbar-button-slimmer.js

@@ -10,6 +10,7 @@ import image from '../../../assets/image';
 import { h } from '@stencil/core';
 import { MapToComponentField } from 'vega-slimmer/core';
 import { NodeAnnotationTypeEnum } from '../../../dto/annotations/node-annotation.abstract';
+import { ImageUpdateUrlAction } from '../../../dto/actions/image-update-url-action';
 export class ImageToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   constructor() {
     super({
@@ -35,7 +36,7 @@ export class ImageToolbarButtonSlimmer extends ToolbarButtonSlimmer {
         this.updateNodeURLMap = new Map();
       }
       this.updateNodeURLMap.set(node, (url) => {
-        node.url = url;
+        node.apply(new ImageUpdateUrlAction(url));
       });
       const payload = {
         file: input.files[0],

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/action-handle-strategy-registry.test.js

@@ -0,0 +1,41 @@
+import { LogUtility } from '../../../../../utils/log';
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+class MockAnnotationAction extends AnnotationAction {
+  constructor() {
+    super(...arguments);
+    this.isFlushable = false;
+    this.toAnnotation = jest.fn();
+  }
+}
+class MockStrategy extends ActionHandleStrategy {
+  constructor() {
+    super(...arguments);
+    this.handleAction = jest.fn();
+  }
+}
+const strategy = new MockStrategy();
+test('ActionHandleStrategyRegistry methods register and get should work properly', () => {
+  expect(ActionHandleStrategyRegistry.get(MockAnnotationAction.name, RTETextNode.name)).toBeUndefined();
+  ActionHandleStrategyRegistry.register(MockAnnotationAction.name, RTETextNode.name, strategy);
+  expect(ActionHandleStrategyRegistry.get('MockAnnotationAction', 'RTETextNode')).toEqual(strategy);
+});
+test('ActionHandleStrategyRegistry methods executeTheStrategy should work properly', () => {
+  spyOn(strategy, 'execute').and.callThrough();
+  spyOn(strategy, 'handleAction');
+  const action = new MockAnnotationAction();
+  const target = new RTETextNode('1', 'test', null);
+  ActionHandleStrategyRegistry.executeTheStrategy(action, target);
+  expect(strategy.execute).toBeCalledWith(action, target);
+  expect(strategy.handleAction).toBeCalledWith(action, target);
+});
+test('ActionHandleStrategyRegistry methods executeTheStrategy should log error if the strategy is not exist', () => {
+  spyOn(LogUtility, 'error');
+  const action = new MockAnnotationAction();
+  const target = new RTEImageNode('1', 'test url', null);
+  ActionHandleStrategyRegistry.executeTheStrategy(action, target);
+  expect(LogUtility.error).toBeCalledWith(`Type MockAnnotationAction action handle strategy is not registered in class RTEImageNode`);
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/block-insert-line-break-with-blocks-strategy.test.js

@@ -0,0 +1,24 @@
+import { BlockInsertLineBreakWithBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
+import { lineBreakMultipleBlocksAction } from '../../../dto/actions/line-break-multiple-block-action';
+import { VegaRTEContent } from '../../../dto/content-state';
+test('BlockInsertLineBreakWithBlocksStrategy should work properly', () => {
+  const strategy = new BlockInsertLineBreakWithBlocksStrategy();
+  const contentState = VegaRTEContent.fromJSON([
+    {
+      id: '1',
+      type: 'paragraph',
+      nodes: [
+        { id: '1-1', type: 'text', text: 'A' },
+        { id: '1-1', type: 'text', text: 'B' },
+      ],
+    },
+    {
+      id: '2',
+      type: 'paragraph',
+      nodes: [],
+    },
+  ]);
+  const action = new lineBreakMultipleBlocksAction(contentState.blocks);
+  strategy.execute(action, contentState.blocks[0]);
+  expect(contentState.blocks[0]['nodes'].length).toEqual(4);
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/content-state-strategy-registry.test.js

@@ -0,0 +1,14 @@
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { BlockAppendBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
+import { BlockInsertBlocksAfterStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy';
+import { BlockInsertBlocksBeforeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy';
+import { BlockRemoveChildBlockStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-remove-child-block-strategy';
+import { ModifyContentActionType } from '../../../dto/actions/modify-content-action.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+test('VegaRTEContent action strategy should register properly', () => {
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_CHILD, VegaRTEContent.name) instanceof
+    BlockRemoveChildBlockStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.APPEND_CHILD_NODES, VegaRTEContent.name) instanceof BlockAppendBlocksStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_BLOCKS_BEFORE, VegaRTEContent.name) instanceof BlockInsertBlocksBeforeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_BLOCKS_AFTER, VegaRTEContent.name) instanceof BlockInsertBlocksAfterStrategy).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/image-block-strategy-register.test.js

@@ -0,0 +1,30 @@
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { BlockAppendNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
+import { BlockDeleteImageStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-delete-image-strategy';
+import { BlockInsertNodesAfterNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-after-node-strategy';
+import { BlockInsertNodesBeforeNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
+import { BlockMergeNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
+import { BlockRemoveNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-remove-node-strategy';
+import { BlockReplaceNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
+import { BlockSplitWithImageNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-split-with-image-node-strategy';
+import { ImageBlockInsertImageStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/image-block-insert-image-strategy';
+import { ImageInsertLineBreakStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-strategy';
+import { ImageInsertLineBreakWithBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-with-blocks-strategy';
+import { ImageInsertNewParagraphStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/image-insert-new-paragraph-strategy';
+import { ModifyContentActionType } from '../../../dto/actions/modify-content-action.abstract';
+import { RTEImageBlock } from '../../../dto/blocks/image-block';
+test('RTEImageBlock should register action handle strategy properly', () => {
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEImageBlock.name) instanceof BlockDeleteImageStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEImageBlock.name) instanceof BlockMergeNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_CHILD, RTEImageBlock.name) instanceof
+    BlockRemoveNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.APPEND_CHILD_NODES, RTEImageBlock.name) instanceof BlockAppendNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.REPLACE_CHILD_NODES, RTEImageBlock.name) instanceof BlockReplaceNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEImageBlock.name) instanceof BlockSplitWithImageNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEImageBlock.name) instanceof ImageInsertNewParagraphStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEImageBlock.name) instanceof ImageInsertLineBreakStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEImageBlock.name) instanceof ImageInsertLineBreakWithBlocksStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEImageBlock.name) instanceof ImageBlockInsertImageStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_NODES_BEFORE, RTEImageBlock.name) instanceof BlockInsertNodesBeforeNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_NODES_AFTER, RTEImageBlock.name) instanceof BlockInsertNodesAfterNodeStrategy).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/image-set-annotation-map-strategy.test.js

@@ -0,0 +1,11 @@
+import { ImageAnnotationAction } from '../../../dto/actions/image-annotation-action';
+import { SelectionChangeAction } from '../../../dto/actions/selection-change-action';
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+test('ImageSetAnnotationMapStrategy should register properly', () => {
+  const imageNode = new RTEImageNode('1', 'mock image url', null);
+  imageNode.apply(new ImageAnnotationAction('lg', 'alt'));
+  expect(imageNode.toJSON().annotations.size).toEqual('lg');
+  const mockRange = new Object();
+  imageNode.apply(new SelectionChangeAction(mockRange));
+  expect(imageNode.getAnnotationByType('SELECTION_RANGE')['range']).toEqual(mockRange);
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/image-update-url-strategy.test.js

@@ -0,0 +1,16 @@
+import { ImageUpdateUrlStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/image-update-url-strategy';
+import { ImageUpdateUrlAction } from '../../../dto/actions/image-update-url-action';
+import { RTEImageNode } from '../../../dto/nodes/image-node';
+const strategy = new ImageUpdateUrlStrategy();
+test('ImageUpdateUrlStrategy should work properly', () => {
+  const imageNode = new RTEImageNode('1', 'default image url', null);
+  const newUrl = 'new image url';
+  strategy.execute(new ImageUpdateUrlAction(newUrl), imageNode);
+  expect(imageNode.url).toEqual(newUrl);
+});
+test('ImageUpdateUrlStrategy should register into image node properly', () => {
+  const imageNode = new RTEImageNode('1', 'default image url', null);
+  const newUrl = 'new image url';
+  imageNode.apply(new ImageUpdateUrlAction(newUrl));
+  expect(imageNode.url).toEqual(newUrl);
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/list-block-strategy-register.test.js

@@ -0,0 +1,20 @@
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { BlockAppendBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-append-blocks-strategy';
+import { BlockInsertBlocksAfterStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy';
+import { BlockInsertBlocksBeforeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy';
+import { ListInsertImageStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-insert-image-strategy';
+import { ListRemoveListItemStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-remove-list-item-strategy';
+import { ListTransformToListStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy';
+import { ListTransformToParagraphStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy';
+import { ModifyContentActionType } from '../../../dto/actions/modify-content-action.abstract';
+import { RTEListBlock } from '../../../dto/blocks/list-block';
+test('RTEListBlock strategy should register properly', () => {
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_CHILD, RTEListBlock.name) instanceof
+    ListRemoveListItemStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_BLOCKS_BEFORE, RTEListBlock.name) instanceof BlockInsertBlocksBeforeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_BLOCKS_AFTER, RTEListBlock.name) instanceof BlockInsertBlocksAfterStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.APPEND_CHILD_NODES, RTEListBlock.name) instanceof BlockAppendBlocksStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name) instanceof ListTransformToListStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name) instanceof ListTransformToParagraphStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name) instanceof ListInsertImageStrategy).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/list-item-strategy-register.test.js

@@ -0,0 +1,31 @@
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { BlockAppendNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
+import { BlockInsertLineBreakStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy';
+import { BlockInsertLineBreakWithBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
+import { BlockInsertNodesBeforeNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
+import { BlockMergeNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
+import { BlockReplaceNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
+import { BlockSplitWithTextNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy';
+import { ListItemDeleteTextContentStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-delete-text-content-strategy';
+import { ListItemInsertImageStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-insert-image-strategy';
+import { ListItemInsertNewParagraphStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-insert-new-paragraph-strategy';
+import { ListItemRemoveNestListStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-remove-nest-list-strategy';
+import { ListItemRemoveNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-remove-node-strategy';
+import { ListItemReplaceNestListStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/list-item-replace-nest-list-strategy';
+import { ModifyContentActionType } from '../../../dto/actions/modify-content-action.abstract';
+import { RTEListItemBlock } from '../../../dto/blocks/list-item-block';
+test('RTEListItemBlock should register action handle strategy properly', () => {
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTEListItemBlock.name) instanceof ListItemDeleteTextContentStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTEListItemBlock.name) instanceof BlockInsertLineBreakStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTEListItemBlock.name) instanceof BlockInsertLineBreakWithBlocksStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_CHILD, RTEListItemBlock.name) instanceof ListItemRemoveNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_NEST_LIST, RTEListItemBlock.name) instanceof ListItemRemoveNestListStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.APPEND_CHILD_NODES, RTEListItemBlock.name) instanceof BlockAppendNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTEListItemBlock.name) instanceof BlockSplitWithTextNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.REPLACE_CHILD_NODES, RTEListItemBlock.name) instanceof BlockReplaceNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.REPLACE_NEST_LIST, RTEListItemBlock.name) instanceof ListItemReplaceNestListStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTEListItemBlock.name) instanceof BlockMergeNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTEListItemBlock.name) instanceof ListItemInsertNewParagraphStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListItemBlock.name) instanceof ListItemInsertImageStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_NODES_BEFORE, RTEListItemBlock.name) instanceof BlockInsertNodesBeforeNodeStrategy).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/node-split-text-strategy.test.js

@@ -0,0 +1,31 @@
+import { NodeSplitTextStrategy } from '../../../dto/action-handle-strategies/apply-annotation-strategies/node-split-text-strategy';
+import { AppendChildNodesAction } from '../../../dto/actions/append-child-nodes-action';
+import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-action';
+import { SelectionRangeAnnotation } from '../../../dto/annotations/selection-range-annotation';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+function getMockSelectionRange(startContainer, endContainer, startOffset, endOffset) {
+  return {
+    startContainer,
+    endContainer,
+    startOffset,
+    endOffset,
+  };
+}
+const splitTextStrategy = new NodeSplitTextStrategy();
+test('NodeSplitTextStrategy execute method should return value properly', () => {
+  const p = document.createElement('p');
+  p.innerHTML = '<span>A Paragraph</span>';
+  const block = new RTETextBlock('1', 'paragraph');
+  const textNode = new RTETextNode('1-1', 'A Paragraph', block);
+  block.apply(new AppendChildNodesAction([textNode]));
+  let result = splitTextStrategy.execute(new BoldAnnotationAction(false), textNode);
+  expect(result).toBeNull;
+  const span = p.querySelector('span');
+  textNode.annotationMap.set('SELECTION_RANGE', new SelectionRangeAnnotation(getMockSelectionRange(span.firstChild, span.firstChild, 1, 1)));
+  stateEntityRenderingRegistry.register(span, textNode);
+  result = splitTextStrategy.execute(new BoldAnnotationAction(true), textNode);
+  expect(block.nodes.length).toEqual(3);
+  expect(result instanceof RTETextNode).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/node-update-annotation-map-strategy.test.js

@@ -0,0 +1,17 @@
+import { NodeUpdateAnnotationMapStrategy } from '../../../dto/action-handle-strategies/apply-annotation-strategies/node-update-annotation-map-strategy';
+import { AppendChildNodesAction } from '../../../dto/actions/append-child-nodes-action';
+import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-action';
+import { CodeAnnotationAction } from '../../../dto/actions/code-annotation-action';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+const updateAnnotationMapStrategy = new NodeUpdateAnnotationMapStrategy();
+test('NodeUpdateAnnotationMapStrategy execute method should work properly', () => {
+  const block = new RTETextBlock('1', 'paragraph');
+  const textNode = new RTETextNode('1-1', 'A Paragraph', block);
+  block.apply(new AppendChildNodesAction([textNode]));
+  updateAnnotationMapStrategy.execute(new BoldAnnotationAction(true), textNode);
+  expect(textNode.getAnnotationByType('BOLD')['toJSON']()).toEqual({ bold: true });
+  updateAnnotationMapStrategy.execute(new CodeAnnotationAction(true), textNode);
+  expect(textNode.getAnnotationByType('CODE')['toJSON']()).toEqual({ code: true });
+  expect(textNode.annotationMap.has('BOLD')).toEqual(false);
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/text-block-strategy-register.test.js

@@ -0,0 +1,55 @@
+import { ActionHandleStrategyRegistry } from '../../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { BlockAppendNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-append-nodes-strategy';
+import { BlockDeleteTextContentStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-delete-text-content-strategy';
+import { BlockInsertImageIntoTextStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-image-into-text-strategy';
+import { BlockInsertLineBreakStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy';
+import { BlockInsertLineBreakWithBlocksStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy';
+import { BlockInsertNewParagraphStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-strategy';
+import { BlockInsertNodesBeforeNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy';
+import { BlockMergeNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy';
+import { BlockRemoveNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-remove-node-strategy';
+import { BlockReplaceNodesStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy';
+import { BlockSplitWithTextNodeStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy';
+import { BlockTransformToListStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy';
+import { ModifyContentActionType } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { BlockUpdateLinkGroupStrategy } from '../../../dto/action-handle-strategies/apply-annotation-strategies/block-update-link-group-strategy';
+import { BlockUpdateTextStyleStrategy } from '../../../dto/action-handle-strategies/apply-annotation-strategies/block-update-text-style-strategy';
+import { LinkGroupAnnotationAction } from '../../../dto/actions/link-group-annotation-action';
+import { TextStyleAnnotationAction } from '../../../dto/actions/text-style-annotation-action';
+import { InternalAnnotationTypeEnum } from '../../../dto/annotations/annotation.abstract';
+test('RTETextBlock annotation strategy should register properly', () => {
+  expect(ActionHandleStrategyRegistry.get(TextStyleAnnotationAction.name, RTETextBlock.name) instanceof
+    BlockUpdateTextStyleStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(LinkGroupAnnotationAction.name, RTETextBlock.name) instanceof
+    BlockUpdateLinkGroupStrategy).toBeTruthy();
+});
+test('RTETextBlock apply annotation action should work properly', () => {
+  const textBlock = RTETextBlock.from({
+    id: '1',
+    type: 'subtitle',
+    nodes: [{ id: '1-1', type: 'text', text: 'Paragraph' }],
+  });
+  expect(textBlock.nodes[0].annotationMap.has('BOLD')).toBeFalsy();
+  textBlock.apply(new TextStyleAnnotationAction('paragraph', true));
+  expect(textBlock.type).toEqual('paragraph');
+  expect(textBlock.nodes[0].getAnnotationByType('BOLD')['toJSON']()['bold']).toBeTruthy();
+  expect(textBlock.annotationMap.has(InternalAnnotationTypeEnum.LINK_GROUP)).toBeFalsy();
+  textBlock.apply(new LinkGroupAnnotationAction('1', textBlock.nodes));
+  expect(textBlock.annotationMap.has(InternalAnnotationTypeEnum.LINK_GROUP)).toBeTruthy();
+});
+test('RTETextBlock should register action handle strategy properly', () => {
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_CHILD, RTETextBlock.name) instanceof
+    BlockRemoveNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.APPEND_CHILD_NODES, RTETextBlock.name) instanceof BlockAppendNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.SPLIT_BLOCK_WITH_NODE, RTETextBlock.name) instanceof BlockSplitWithTextNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.REPLACE_CHILD_NODES, RTETextBlock.name) instanceof BlockReplaceNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.MERGE_TWO_BLOCKS_NODES, RTETextBlock.name) instanceof BlockMergeNodesStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.BREAK_SINGLE_BLOCK, RTETextBlock.name) instanceof BlockInsertNewParagraphStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_SINGLE_BLOCK, RTETextBlock.name) instanceof BlockInsertLineBreakStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.LINE_BREAK_MULTIPLE_BLOCKS, RTETextBlock.name) instanceof BlockInsertLineBreakWithBlocksStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.DELETE_BLOCK_CONTENT, RTETextBlock.name) instanceof BlockDeleteTextContentStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTETextBlock.name) instanceof BlockInsertImageIntoTextStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.INSERT_NODES_BEFORE, RTETextBlock.name) instanceof BlockInsertNodesBeforeNodeStrategy).toBeTruthy();
+  expect(ActionHandleStrategyRegistry.get(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTETextBlock.name) instanceof BlockTransformToListStrategy).toBeTruthy();
+});

package/dist/collection/components/vega-rich-text-editor/test/dto/action-handle-strategies/update-selected-text-strategy.test.js

@@ -0,0 +1,23 @@
+import { NodeReplaceSelectedTextStrategy } from '../../../dto/action-handle-strategies/modify-content-strategies/node-replace-selected-text-strategy';
+import { ReplaceSelectedTextAction } from '../../../dto/actions/replace-selected-text-action';
+import { RTETextNode } from '../../../dto/nodes/text-node';
+import { RTERange } from '../../../dto/range';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+test('UpdateSelectedNodeStrategy should update text properly', () => {
+  const span = document.createElement('span');
+  span.innerText = 'paragraph';
+  const textNode = new RTETextNode('1', span.innerText, null);
+  stateEntityRenderingRegistry.register(span, textNode);
+  const strategy = new NodeReplaceSelectedTextStrategy();
+  strategy.execute(new ReplaceSelectedTextAction('new text', new RTERange(span.firstChild, span.firstChild, 0, 9)), textNode);
+  expect(textNode.text).toEqual('new text');
+});
+test('UpdateSelectedNodeStrategy should update text properly if the range is collapsed', () => {
+  const span = document.createElement('span');
+  span.innerText = 'paragraph';
+  const textNode = new RTETextNode('1', span.innerText, null);
+  stateEntityRenderingRegistry.register(span, textNode);
+  const strategy = new NodeReplaceSelectedTextStrategy();
+  strategy.execute(new ReplaceSelectedTextAction('This is a ', new RTERange(span.firstChild, span.firstChild, 0, 0)), textNode);
+  expect(textNode.text).toEqual('This is a paragraph');
+});