@globalpayments/vega 2.34.1 → 2.35.0

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/block-text-nodes-renderer.abstract.js

@@ -0,0 +1,104 @@
+import { h } from '@stencil/core';
+import { InternalAnnotationTypeEnum } from '../../annotations/annotation.abstract';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import RTETextNodeRenderer from '../nodes/text-node-renderer';
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { isNonNullable } from '../../../../../types/type-guard';
+import { generateUUID } from '../../../../../utils/misc';
+import { LinkAnnotationAction } from '../../actions/link-annotation-action';
+import { createEnterKeyHandlerToTriggerClick } from '../../../../../utils/accessibility';
+import { DomNodeSubjectObserverFactory } from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
+import { VegaChange } from '../../../../../helpers/event-manager/event-id/vega-event-id';
+/**
+ * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
+ */
+export class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
+  renderNodes(block, renderContext) {
+    const linkGroupAnnotation = block.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
+    return linkGroupAnnotation
+      ? this.renderLinkNodes(block.nodes, renderContext)
+      : block.nodes.map((node) => RTETextNodeRenderer.render(node));
+  }
+  renderLinkNodes(nodes, { editable }) {
+    const blockNodes = this.groupNodesByLink(nodes);
+    return blockNodes.flatMap((item) => {
+      if (this.isLinkGroup(item)) {
+        const linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+        return editable
+          ? this.renderLinkEditorWrapper(item, linkAnnotation)
+          : this.renderLink(item, linkAnnotation);
+      }
+      return RTETextNodeRenderer.render(item);
+    });
+  }
+  groupNodesByLink(nodes) {
+    return nodes.reduce((acc, node) => {
+      const nodeLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+      const lastGroup = acc[acc.length - 1];
+      if (isNonNullable(nodeLinkAnnotation)) {
+        if (lastGroup &&
+          this.isLinkGroup(lastGroup) &&
+          lastGroup[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK).toEqual(nodeLinkAnnotation)) {
+          lastGroup.push(node);
+        }
+        else {
+          acc.push([node]);
+        }
+      }
+      else {
+        acc.push(node);
+      }
+      return acc;
+    }, []);
+  }
+  isLinkGroup(item) {
+    return Array.isArray(item);
+  }
+  renderLinkEditorWrapper(linkNodes, linkAnnotation) {
+    const { href } = linkAnnotation.link;
+    const textFromNodes = linkNodes.map((node) => node.text).join('');
+    const handleChange = ({ detail, }) => {
+      switch (detail.action) {
+        case 'link': {
+          const { url, text } = detail.payload;
+          const textChanged = text !== textFromNodes;
+          const groupKey = generateUUID();
+          linkNodes.forEach((node) => {
+            const linkAnnotationAction = new LinkAnnotationAction({
+              link: { href: url, groupKey: groupKey },
+              newText: textChanged ? text : undefined,
+              needMergeNode: textChanged && linkNodes.length > 1,
+              doSplit: false,
+            });
+            node.apply(linkAnnotationAction);
+          });
+          return;
+        }
+        case 'unlink': {
+          linkNodes.forEach((node) => node.deleteAnnotationByType(NodeAnnotationTypeEnum.LINK));
+          return;
+        }
+      }
+    };
+    let linkWrapperRef;
+    return (h("span", { class: "link-editor-wrapper", role: "link", tabIndex: 0, onKeyDown: createEnterKeyHandlerToTriggerClick(), ref: (ref) => {
+        if (ref) {
+          linkWrapperRef = ref;
+        }
+      } },
+      this.renderLink(linkNodes, linkAnnotation),
+      h("vega-rich-text-link-editor", { record: {
+          text: textFromNodes,
+          url: href,
+        }, ref: (ref) => {
+          if (ref) {
+            ref.target = linkWrapperRef;
+            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, handleChange);
+          }
+        } })));
+  }
+  renderLink(linkNodes, linkAnnotation) {
+    const { href } = linkAnnotation.link;
+    return (h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => RTETextNodeRenderer.render(node))));
+  }
+}

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

@@ -0,0 +1,15 @@
+import { h } from '@stencil/core';
+import { RTEImageBlock } from '../../blocks/image-block';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import RTEImageNodeRenderer from '../nodes/image-node-renderer';
+class RTEImageBlockRenderer extends RTEBlockRenderer {
+  canHandle(block) {
+    return block instanceof RTEImageBlock;
+  }
+  render(block, renderContext) {
+    return (h("div", { style: Object.assign({}, super.getStyles(block)), ref: (ref) => super.registerRef(ref, block), class: super.getClasses(block) }, block.nodes.map((node) => {
+      return RTEImageNodeRenderer.render(node, renderContext);
+    })));
+  }
+}
+export default new RTEImageBlockRenderer();

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

@@ -0,0 +1,14 @@
+import { h } from '@stencil/core';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+import RTEListItemBlockRenderer from './list-item-block-renderer';
+class RTEListBlockRenderer extends RTEBlockRenderer {
+  canHandle(block) {
+    return block instanceof RTEListBlock;
+  }
+  render(block, renderContext) {
+    const BlockTag = block.type === 'number-list' ? 'ol' : 'ul';
+    return (h(BlockTag, { ref: (ref) => super.registerRef(ref, block) }, block.blocks.map((listItemBlock) => RTEListItemBlockRenderer.render(listItemBlock, renderContext))));
+  }
+}
+export default new RTEListBlockRenderer();

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

@@ -0,0 +1,14 @@
+import { h } from '@stencil/core';
+import RTEListBlockRenderer from './list-block-renderer';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  render(block, renderContext) {
+    return (h("li", { ref: (ref) => super.registerRef(ref, block), style: super.getStyles(block), class: super.getClasses(block) },
+      super.renderNodes(block, renderContext),
+      this.renderChildren(block.children, renderContext)));
+  }
+  renderChildren(children, renderContext) {
+    return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer.render(block, renderContext));
+  }
+}
+export default new RTEListItemBlockRenderer();

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

@@ -0,0 +1,28 @@
+import { h } from '@stencil/core';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  canHandle(block) {
+    return block instanceof RTETextBlock;
+  }
+  render(block, renderContext) {
+    const BlockTag = this.getBlockTagByType(block.type);
+    return (h(BlockTag, { ref: (ref) => super.registerRef(ref, block), style: super.getStyles(block), class: super.getClasses(block) }, super.renderNodes(block, renderContext)));
+  }
+  getBlockTagByType(type) {
+    switch (type) {
+      case 'title':
+      case 'subtitle':
+        return `div`;
+      case 'heading-1':
+        return `h1`;
+      case 'heading-2':
+        return `h2`;
+      case 'heading-3':
+        return `h3`;
+      case 'paragraph':
+        return 'p';
+    }
+  }
+}
+export default new RTETextBlockRenderer();

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

@@ -0,0 +1,49 @@
+import { h } from '@stencil/core';
+import { ImageAnnotation } from '../../annotations/image-annotation';
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { ImageAnnotationAction } from '../../actions/image-annotation-action';
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+import { DomNodeSubjectObserverFactory } from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
+import { VegaChange } from '../../../../../helpers/event-manager/event-id/vega-event-id';
+import { RTENodeRenderer } from './node-renderer.abstract';
+class RTEImageNodeRenderer extends RTENodeRenderer {
+  constructor() {
+    super(...arguments);
+    this.handleChange = ({ detail }, node) => {
+      switch (detail.action) {
+        case 'edit': {
+          const size = detail.payload.size;
+          const alt = detail.payload.alt;
+          node.apply(new ImageAnnotationAction(size, alt));
+          break;
+        }
+        /*
+         * The below method is e2e-test covered in
+         * @see{module:vega-rich-text-editor-image-click-delete-button}
+         */
+        /* istanbul ignore next */
+        case 'delete': {
+          const event = new InputEvent('beforeinput', {
+            inputType: 'deleteContentBackward',
+            bubbles: true,
+          });
+          setTimeout(() => {
+            stateEntityRenderingRegistry.getDOMByEntity(node).dispatchEvent(event);
+          }, 50);
+          break;
+        }
+      }
+    };
+  }
+  render(node, renderContext) {
+    const imageAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.IMAGE);
+    const { size, alt } = imageAnnotation || new ImageAnnotation('md', '');
+    return renderContext.editable ? (h("vega-rich-text-image-editor", { style: super.getStyles(node), size: size, alt: alt, ref: (ref) => {
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, (e) => this.handleChange(e, node));
+      } }, this.renderImage(alt, node, renderContext))) : (this.renderImage(alt, node, renderContext));
+  }
+  renderImage(alt, node, renderContext) {
+    return (h("img", { style: renderContext.editable ? { width: '100%' } : super.getStyles(node), alt: alt, src: node.url, ref: (ref) => super.registerRef(ref, node) }));
+  }
+}
+export default new RTEImageNodeRenderer();

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

@@ -0,0 +1,35 @@
+import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
+import { NodeAnnotation } from '../../annotations/node-annotation.abstract';
+export class RTENodeRenderer {
+  registerRef(ref, node) {
+    if (ref) {
+      stateEntityRenderingRegistry.register(ref, node);
+    }
+  }
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  getStyles(node) {
+    return Array.from(node.annotationMap.values())
+      .filter((annotation) => annotation instanceof NodeAnnotation)
+      .map((annotation) => annotation.render())
+      .filter(Boolean)
+      .reduce((current, obj) => (Object.assign(Object.assign({}, current), obj)), {});
+  }
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  getClasses(node) {
+    return Array.from(node.annotationMap.values())
+      .filter((annotation) => annotation instanceof NodeAnnotation)
+      .map((annotation) => { var _a; return (_a = annotation.renderClass) === null || _a === void 0 ? void 0 : _a.call(annotation); })
+      .filter(Boolean)
+      .reduce((pre, cur) => [pre, cur].join(' '), '');
+  }
+}

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

@@ -0,0 +1,24 @@
+import { h } from '@stencil/core';
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { NodeAnnotationTypeEnum } from '../../annotations/node-annotation.abstract';
+import { ZERO_WIDTH_SPACE } from '../../../constants/constant';
+import TextNodeElementRenderingRegistry from '../../../slimmers/controllers/text-node-rendering-registry';
+class RTETextNodeRenderer extends RTENodeRenderer {
+  render(node) {
+    const codeAnnotation = node.annotationMap.get(NodeAnnotationTypeEnum.CODE);
+    if (codeAnnotation === null || codeAnnotation === void 0 ? void 0 : codeAnnotation.code) {
+      return (h("code", { style: super.getStyles(node), class: super.getClasses(node), ref: (ref) => this.registerRef(ref, node) }, node.text || ZERO_WIDTH_SPACE));
+    }
+    return (h("span", { style: super.getStyles(node), class: super.getClasses(node), ref: (ref) => this.registerRef(ref, node) }, node.text || ZERO_WIDTH_SPACE));
+  }
+  registerRef(ref, node) {
+    super.registerRef(ref, node);
+    if (ref) {
+      const textColorAnnotation = node.getAnnotationByType('TEXT_COLOR');
+      if (textColorAnnotation) {
+        TextNodeElementRenderingRegistry.register(ref, textColorAnnotation);
+      }
+    }
+  }
+}
+export default new RTETextNodeRenderer();

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.js

@@ -7,12 +7,14 @@ import { ImgToRTEImageBlockStrategy } from './img-to-rte-image-block-strategy';
 import { VegaImageToRTEImageBlockStrategy } from './vega-image-to-rte-image-block-strategy';
 import { OlToRTEListBlockStrategy } from './ol-to-rte-list-block-strategy';
 import { SpanImageToRTEImageBlockStrategy } from './span-img-to-rte-image-block-strategy';
+import { ULNotLiChildToRTEListItemBlockStrategy } from './ul-not-li-child-to-rte-list-item-block';
 /** Element to DTO processor */
 export class ElementToDtoStrategyProcessor {
   constructor() {
     this.elementStrategies = [
       new UlToRTEListBlockStrategy(),
       new OlToRTEListBlockStrategy(),
+      new ULNotLiChildToRTEListItemBlockStrategy(),
       new LiToRTEListItemBlockStrategy(),
       new InlineBlockToRTETextBlockStrategy(),
       new ImgToRTEImageBlockStrategy(),

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ul-not-li-child-to-rte-list-item-block.js

@@ -0,0 +1,49 @@
+import { generateUUID } from '../../../../../../utils/misc';
+import { RTEListItemBlock } from '../../../../dto/blocks/list-item-block';
+import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+/** Transform child element of UL element which are not LI element to list item block DTO */
+export class ULNotLiChildToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {number} currentIndex - Current element index.
+   * @returns {number} - can be handled element count.
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    const parent = element.parentElement;
+    return element.nodeName !== 'LI' && parent && ['UL', 'OL'].includes(parent.nodeName) ? 1 : 0;
+  }
+  /**
+   * Parse to a list item block.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @returns {Nullable<RTEContentBlock>} - List item block.
+   */
+  handle(elementsArray) {
+    const nodes = this.generateChildNodes(elementsArray);
+    if (nodes.length === 0)
+      return null;
+    return RTEListItemBlock.from({
+      id: generateUUID(),
+      type: 'list-item',
+      nodes: nodes,
+      annotations: {},
+    });
+  }
+  /* istanbul ignore next */
+  /**
+   * Append child blocks.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  appendChildBlocks() { }
+  /**
+   * Should continue process to child elements.
+   *
+   * @returns {boolean} - boolean.
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+}

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

@@ -1,5 +1,3 @@
-import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-action';
-import { HorizontalAlignmentAnnotationAction } from '../../../dto/actions/horizontal-alignment-annotation-action';
 import { RTEImageBlock } from '../../../dto/blocks/image-block';
 import { RTEImageNode } from '../../../dto/nodes/image-node';
 describe('image block', () => {
@@ -64,14 +62,6 @@ describe('image block', () => {
       annotations: { indent: 2 },
     });
   });
-  it('render method should work as expect', () => {
-    const imageBlock = new RTEImageBlock('block-1');
-    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
-    imageBlock.nodes = [imageNode];
-    imageNode.apply(new BoldAnnotationAction(true));
-    imageBlock.apply(new HorizontalAlignmentAnnotationAction('right'));
-    expect(imageBlock.render()).toBeDefined();
-  });
   it('isNotEmpty should work as expect', () => {
     const imageBlock = new RTEImageBlock('block-1');
     const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);

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

@@ -1,5 +1,4 @@
 import { RTEListBlock } from '../../../dto/blocks/list-block';
-import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
 describe('bullet list', () => {
   it('new RTEBulletListBlock should work as expect', () => {
     expect(new RTEListBlock('1', 'bullet-list')).toBeDefined();
@@ -61,33 +60,6 @@ describe('bullet list', () => {
       ],
     });
   });
-  it('registerRef method should work as expect', () => {
-    const bulletListBlock = new RTEListBlock('1', 'bullet-list');
-    const mockDiv = document.createElement('div');
-    bulletListBlock['registerRef'](mockDiv);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(bulletListBlock)).toEqual(mockDiv);
-    expect(stateEntityRenderingRegistry.getEntityByDOM(mockDiv)).toEqual(bulletListBlock);
-  });
-  it('render method should work as expect', () => {
-    expect(new RTEListBlock('1', 'bullet-list').render()).toBeDefined();
-    expect(RTEListBlock.from({
-      id: '1-1-1',
-      type: 'bullet-list',
-      blocks: [
-        {
-          id: '1-1-1-1',
-          type: 'list-item',
-          nodes: [
-            {
-              id: '1-1-1-1-1',
-              type: 'text',
-              text: 'This is a bullet-list 3-1.',
-            },
-          ],
-        },
-      ],
-    }).render()).toBeDefined();
-  });
   it('isNotEmpty should work as expect', () => {
     const bulletListBlock = RTEListBlock.from({
       id: '1',
@@ -133,26 +105,6 @@ describe('bullet list', () => {
   });
 });
 describe('number list', () => {
-  it('render method should work as expect', () => {
-    expect(new RTEListBlock('1', 'bullet-list').render()).toBeDefined();
-    expect(RTEListBlock.from({
-      id: '1-1-1',
-      type: 'number-list',
-      blocks: [
-        {
-          id: '1-1-1-1',
-          type: 'list-item',
-          nodes: [
-            {
-              id: '1-1-1-1-1',
-              type: 'text',
-              text: 'This is a bullet-list 3-1.',
-            },
-          ],
-        },
-      ],
-    }).render()).toBeDefined();
-  });
   it('isNotEmpty should work as expect', () => {
     const listBlock = RTEListBlock.from({
       id: '1',

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

@@ -1,6 +1,5 @@
 import { RTEListItemBlock } from '../../../dto/blocks/list-item-block';
 import { RTETextNode } from '../../../dto/nodes/text-node';
-import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
 describe('bullet list item', () => {
   it('new RTEBulletListItemBlock should work as expect', () => {
     const bulletListItemBlock = new RTEListItemBlock('1');
@@ -129,45 +128,6 @@ describe('bullet list item', () => {
       ],
     });
   });
-  it('render method should work as expect', () => {
-    expect(RTEListItemBlock.from({
-      id: '1',
-      type: 'list-item',
-      nodes: [
-        {
-          id: '1-1',
-          type: 'text',
-          text: 'This is a bullet-list 1.',
-        },
-      ],
-      children: [
-        {
-          id: '1-1-1',
-          type: 'bullet-list',
-          blocks: [
-            {
-              id: '1-1-1-1',
-              type: 'list-item',
-              nodes: [
-                {
-                  id: '1-1-1-1-1',
-                  type: 'text',
-                  text: 'This is a bullet-list 3-1.',
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    }).render()).toBeDefined();
-  });
-  it('registerRef method should work as expect', () => {
-    const bulletListItemBlock = new RTEListItemBlock('1');
-    const mockDiv = document.createElement('div');
-    bulletListItemBlock['registerRef'](mockDiv);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(bulletListItemBlock)).toEqual(mockDiv);
-    expect(stateEntityRenderingRegistry.getEntityByDOM(mockDiv)).toEqual(bulletListItemBlock);
-  });
   it('getLastNode should work as expect', () => {
     const listItemBlock = RTEListItemBlock.from({
       id: '1',

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

@@ -1,11 +1,6 @@
 import { RTETextBlock } from '../../../dto/blocks/text-block';
 import { RTETextNode } from '../../../dto/nodes/text-node';
-import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-action';
-import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
 import { TextStyleAnnotationAction } from '../../../dto/actions/text-style-annotation-action';
-import domNodesSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
-import { VegaInternalRichTextEditorFlushChanges } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
-import { HorizontalAlignmentAnnotationAction } from '../../../dto/actions/horizontal-alignment-annotation-action';
 import { SelectionChangeAction } from '../../../dto/actions/selection-change-action';
 describe('text block', () => {
   it('new RTETextBlock should work as expect', () => {
@@ -84,35 +79,6 @@ describe('text block', () => {
       },
     });
   });
-  it('render method should work as expect', () => {
-    const textBlock = new RTETextBlock('block-1', 'paragraph');
-    const textNode = new RTETextNode('1', 'This is a text.', textBlock);
-    textBlock.nodes = [textNode];
-    textNode.apply(new BoldAnnotationAction(true));
-    textBlock.apply(new HorizontalAlignmentAnnotationAction('right'));
-    expect(textBlock.render()).toBeDefined();
-  });
-  it('getBlockTagByType should work as expect', () => {
-    const titleBlock = new RTETextBlock('block-1', 'title');
-    expect(titleBlock['getBlockTagByType'](titleBlock.type)).toEqual('div');
-    const subtitleBlock = new RTETextBlock('block-1', 'subtitle');
-    expect(subtitleBlock['getBlockTagByType'](subtitleBlock.type)).toEqual('div');
-    const heading1Block = new RTETextBlock('block-1', 'heading-1');
-    expect(heading1Block['getBlockTagByType'](heading1Block.type)).toEqual('h1');
-    const heading2Block = new RTETextBlock('block-1', 'heading-2');
-    expect(heading2Block['getBlockTagByType'](heading2Block.type)).toEqual('h2');
-    const heading3Block = new RTETextBlock('block-1', 'heading-3');
-    expect(heading3Block['getBlockTagByType'](heading3Block.type)).toEqual('h3');
-    const paragraphBlock = new RTETextBlock('block-1', 'paragraph');
-    expect(paragraphBlock['getBlockTagByType'](paragraphBlock.type)).toEqual('p');
-  });
-  it('registerRef method should work as expect', () => {
-    const titleBlock = new RTETextBlock('block-1', 'title');
-    const mockDiv = document.createElement('div');
-    titleBlock['registerRef'](mockDiv);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(titleBlock)).toEqual(mockDiv);
-    expect(stateEntityRenderingRegistry.getEntityByDOM(mockDiv)).toEqual(titleBlock);
-  });
   it('apply method should work as expect', () => {
     const titleBlock = new RTETextBlock('block-1', 'title');
     const textNode = new RTETextNode('1', 'This is a text.', titleBlock);
@@ -135,11 +101,6 @@ describe('text block', () => {
     };
     mockDiv.append(mockSpan);
     mockHost.append(mockDiv);
-    titleBlock['registerRef'](mockDiv);
-    textNode['registerRef'](mockSpan);
-    const parentSubject = domNodesSubjectFactory.getSubject(mockHost, VegaInternalRichTextEditorFlushChanges);
-    expect(domNodesSubjectFactory.getSubjectFromParentNodeByEventId(mockDiv, VegaInternalRichTextEditorFlushChanges)).toEqual(parentSubject);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(titleBlock)).toEqual(mockDiv);
     expect(titleBlock.type).toEqual('title');
     textNode.apply(new SelectionChangeAction(range));
     titleBlock.apply(new TextStyleAnnotationAction('heading-1', true));

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

@@ -1,6 +1,5 @@
 import { RTEImageNode } from '../../../dto/nodes/image-node';
 import { RTEImageBlock } from '../../../dto/blocks/image-block';
-import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
 import { ImageAnnotationAction } from '../../../dto/actions/image-annotation-action';
 describe('image node', () => {
   it('new RTEImageNode should work as expect', () => {
@@ -8,19 +7,6 @@ describe('image node', () => {
     const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
     expect(imageNode.toJSON()).toEqual({ id: '1', type: 'image', url: 'mock-url' });
   });
-  it('render method should work as expect', () => {
-    const imageBlock = new RTEImageBlock('block-id');
-    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
-    expect(imageNode.render()).toBeDefined();
-  });
-  it('registerRef method should work as expect', () => {
-    const imageBlock = new RTEImageBlock('block-id');
-    const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);
-    const mockImg = document.createElement('img');
-    imageNode['registerRef'](mockImg);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(imageNode)).toEqual(mockImg);
-    expect(stateEntityRenderingRegistry.getEntityByDOM(mockImg)).toEqual(imageNode);
-  });
   it('apply method should work as expect', () => {
     const imageBlock = new RTEImageBlock('1');
     const imageNode = new RTEImageNode('1', 'mock-url', imageBlock);

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

@@ -15,10 +15,6 @@ import { BoldAnnotationAction } from '../../../dto/actions/bold-annotation-actio
 import { NodeAnnotationTypeEnum } from '../../../dto/annotations/node-annotation.abstract';
 import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-entity-rendering-registry';
 import { SelectionChangeAction } from '../../../dto/actions/selection-change-action';
-import domNodesSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
-import { VegaInternalRichTextEditorFlushChanges } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
-import { UnderlineAnnotationAction } from '../../../dto/actions/underline-annotation-action';
-import { TextColorAnnotationAction } from '../../../dto/actions/text-color-annotation-action';
 import { DeleteNodeAnnotationAction } from '../../../dto/actions/delete-node-annotation-action';
 describe('text node', () => {
   it('new RTETextNode should work as expect', () => {
@@ -91,24 +87,6 @@ describe('text node', () => {
     expect(id).not.toEqual('1');
     expect(rest).toEqual({ text: 'This is a new text.', type: 'text' });
   });
-  it('render method should work as expect with inline style', () => {
-    const textBlock = new RTETextBlock('block-1', 'paragraph');
-    const textNode = new RTETextNode('1', 'This is a text.', textBlock);
-    textNode.apply(new BoldAnnotationAction(true));
-    expect(textNode.render()).toBeDefined();
-  });
-  it('render method should work as expect with class style', () => {
-    const textBlock = new RTETextBlock('block-1', 'paragraph');
-    const textNode = new RTETextNode('1', 'This is a text.', textBlock);
-    textNode.apply(new UnderlineAnnotationAction(true));
-    expect(textNode.render()).toBeDefined();
-  });
-  it('render method should work as expect with text color class style', () => {
-    const textBlock = new RTETextBlock('block-1', 'paragraph');
-    const textNode = new RTETextNode('1', 'This is a text.', textBlock);
-    textNode.apply(new TextColorAnnotationAction('black'));
-    expect(textNode.render()).toBeDefined();
-  });
   it('getAnnotationByType should work as expect', () => {
     const textBlock = new RTETextBlock('block-1', 'paragraph');
     const textNode = new RTETextNode('1', 'This is a text.', textBlock);
@@ -118,24 +96,12 @@ describe('text node', () => {
       type: 'BOLD',
     });
   });
-  it('registerRef method should work as expect', () => {
-    const textBlock = new RTETextBlock('block-1', 'paragraph');
-    const textNode = new RTETextNode('1', 'This is a text.', textBlock);
-    const mockDiv = document.createElement('div');
-    textNode['registerRef'](mockDiv);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(textNode)).toEqual(mockDiv);
-    expect(stateEntityRenderingRegistry.getEntityByDOM(mockDiv)).toEqual(textNode);
-  });
   it('apply method should work as expect', () => {
     const textBlock = new RTETextBlock('block-1', 'paragraph');
     const textNode = new RTETextNode('1', 'This is a text.', textBlock);
     const mockSpan = document.createElement('span');
     const mockHost = document.createElement('div');
     mockHost.append(mockSpan);
-    textNode['registerRef'](mockSpan);
-    const parentSubject = domNodesSubjectFactory.getSubject(mockHost, VegaInternalRichTextEditorFlushChanges);
-    expect(domNodesSubjectFactory.getSubjectFromParentNodeByEventId(mockSpan, VegaInternalRichTextEditorFlushChanges)).toEqual(parentSubject);
-    expect(stateEntityRenderingRegistry.getDOMByEntity(textNode)).toEqual(mockSpan);
     textNode.apply(new BoldAnnotationAction(true));
     expect(textNode.toJSON()).toEqual({
       id: '1',