@globalpayments/vega 2.58.0 → 2.59.1

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/img-to-rte-image-block-strategy.js

@@ -1,8 +1,6 @@
-import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
-import { generateUUID } from '../../../../../../utils/misc';
-import { RTEImageBlock } from '../../../../dto/blocks/image-block';
+import { ElementToRTEImageBlockStrategyAbstract } from './element-to-rte-image-block-strategy.abstract';
 /** Transform img element to image block DTO */
-export class ImgToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+export class ImgToRTEImageBlockStrategy extends ElementToRTEImageBlockStrategyAbstract {
   /**
    * Can be handle.
    *
@@ -17,26 +15,12 @@ export class ImgToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbstract
    * Parse to a image block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Image block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     const element = elementsArray[0];
-    return RTEImageBlock.from({
-      id: generateUUID(),
-      type: 'image',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'image',
-          url: element.src,
-          annotations: {
-            size: 'md',
-            alt: element.alt,
-          },
-        },
-      ],
-      annotations: this.generateBlockAnnotations(element),
-    });
+    return this.createRTEImageBlock(element, options);
   }
   /* istanbul ignore next */
   /**

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

@@ -1,5 +1,6 @@
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
 /** Transform inline block element to text block DTO */
 export class InlineBlockToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
@@ -20,7 +21,7 @@ export class InlineBlockToRTETextBlockStrategy extends BlockToRTEBlockStrategyAb
       'heading-6',
       'title',
       'subtitle',
-    ].includes(this.getElementType(elementsArray[currentIndex]))
+    ].includes(super.matchTextBlockType(elementsArray[currentIndex]))
       ? 1
       : 0;
   }
@@ -28,18 +29,19 @@ export class InlineBlockToRTETextBlockStrategy extends BlockToRTEBlockStrategyAb
    * Parse to a text block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Text block.
    */
-  handle(elementsArray) {
-    const nodes = this.generateChildNodes(elementsArray);
+  handle(elementsArray, options) {
+    const nodes = this.generateChildNodes(Array.from(elementsArray[0].childNodes), {}, options);
     if (nodes.length === 0)
       return null;
     return RTETextBlock.from({
       id: generateUUID(),
-      type: this.getElementType(elementsArray[0]),
+      type: super.matchTextBlockType(elementsArray[0]),
       nodes: nodes,
-      annotations: Object.assign(Object.assign({}, this.generateBlockAnnotations(elementsArray[0])), { textStyle: this.getElementType(elementsArray[0]) }),
-    });
+      annotations: htmlElementToAnnotationGenerator.generate(RTETextBlock, elementsArray[0], options),
+    }, options);
   }
   /* istanbul ignore next */
   /**
@@ -55,46 +57,4 @@ export class InlineBlockToRTETextBlockStrategy extends BlockToRTEBlockStrategyAb
   shouldProceedToElementChildren() {
     return false;
   }
-  /**
-   * Get node type of element.
-   *
-   * @param {HTMLElement} element - element.
-   * @returns {string} - node type.
-   */
-  getElementType(element) {
-    var _a;
-    if (element.nodeType !== Node.TEXT_NODE && element.hasAttribute('data-type')) {
-      return element.getAttribute('data-type');
-    }
-    switch ((_a = element.style) === null || _a === void 0 ? void 0 : _a.fontSize) {
-      case '36px':
-        return 'title';
-      case '28px':
-        return 'subtitle';
-      case '22px':
-        return 'heading-1';
-      case '20px':
-        return 'heading-2';
-      case '18px':
-        return 'heading-3';
-      default:
-        break;
-    }
-    switch (element.nodeName) {
-      case 'H1':
-        return 'heading-1';
-      case 'H2':
-        return 'heading-2';
-      case 'H3':
-        return 'heading-3';
-      case 'H4':
-        return 'heading-4';
-      case 'H5':
-        return 'heading-5';
-      case 'H6':
-        return 'heading-6';
-      default:
-        return '';
-    }
-  }
 }

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

@@ -0,0 +1,46 @@
+import { isHTMLElement } from '../../../../../../utils/ui';
+import { ElementToTextNodeStrategy } from './element-to-text-node-strategy';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import { isNonNullable } from '../../../../../../types/type-guard';
+import { cleanObject } from '../../../../../../utils/object';
+/**
+ * Class to handle inline html element to text node dto
+ */
+export class InlineElementToTextNodeStrategy extends ElementToTextNodeStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    return isHTMLElement(element) && (element.nodeName === 'BR' || element.childNodes.length === 0)
+      ? 1
+      : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options, annotations) {
+    const disableAutoMatchFormat = !!(options && options.autoMatchFormat === false);
+    const parentAnnotations = Object.assign({}, annotations);
+    const child = elementsArray[0];
+    const curAnnotations = htmlElementToAnnotationGenerator.generate(RTETextNode, child, Object.assign({ parentAnnotations: disableAutoMatchFormat
+        ? {
+          inlineHtml: parentAnnotations.inlineHtml,
+          link: parentAnnotations.link,
+          code: parentAnnotations.code,
+        }
+        : annotations }, options));
+    if (child.nodeName === 'BR') {
+      return this.generateTextNode('\n', curAnnotations);
+    }
+    else if (child.childNodes.length === 0) {
+      // For empty dom, there will be no internal iteration, we need to handle it directly here.
+      // Example: <span></span>, <video src='...'></video>
+      const emptyNodeAnnotations = disableAutoMatchFormat
+        ? cleanObject(Object.assign(Object.assign({}, (RTETextNode.supportsHtmlTag(child.nodeName.toLowerCase()) ? curAnnotations : {})), { inlineHtml: curAnnotations.inlineHtml, plainText: isNonNullable(curAnnotations.inlineHtml) }))
+        : curAnnotations;
+      return Object.assign({}, this.generateTextNode('', emptyNodeAnnotations));
+    }
+  }
+}

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

@@ -1,33 +1,49 @@
 import { generateUUID } from '../../../../../../utils/misc';
+import { RTEListBlock } from '../../../../dto/blocks/list-block';
 import { RTEListItemBlock } from '../../../../dto/blocks/list-item-block';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
 /** Transform li element to list item block DTO */
 export class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   /**
-   * Can be handle.
+   * Can be handled.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
    * @param {number} currentIndex - Current element index.
    * @returns {number} - can be handled element count.
    */
   canHandle(elementsArray, currentIndex) {
+    const parent = elementsArray[currentIndex].parentElement;
+    if (!['UL', 'OL'].includes(parent.nodeName) &&
+      elementsArray.some((element) => element.nodeName === 'LI')) {
+      let count = 0;
+      for (let i = currentIndex; i < elementsArray.length; i++) {
+        if (elementsArray[i].nodeName === 'LI') {
+          count++;
+        }
+        else {
+          break;
+        }
+      }
+      return count;
+    }
     return elementsArray[currentIndex].tagName === 'LI' ? 1 : 0;
   }
   /**
    * Parse to a list item block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - List item block.
    */
-  handle(elementsArray) {
-    if (elementsArray[0].childNodes.length === 0)
-      return null;
-    return RTEListItemBlock.from({
-      id: generateUUID(),
-      type: 'list-item',
-      nodes: this.generateChildNodes(Array.from(elementsArray[0].childNodes).filter((item) => !['UL', 'OL'].includes(item.nodeName)), this.generateTextNodeAnnotations(elementsArray[0])),
-      annotations: this.generateBlockAnnotations(elementsArray[0]),
-    });
+  handle(elementsArray, options) {
+    const firstElement = elementsArray[0];
+    const parent = firstElement.parentElement;
+    if (!['UL', 'OL'].includes(parent.nodeName)) {
+      return this.generateWithListBlock(elementsArray, options);
+    }
+    return RTEListItemBlock.from(this.generateListItemBlockDTO(firstElement, options), options);
   }
   /**
    * Append child list blocks to current list item block.
@@ -46,4 +62,37 @@ export class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstrac
   shouldProceedToElementChildren() {
     return true;
   }
+  /**
+   * Generate list block from a list of HTML elements.
+   *
+   * @param {HTMLElement[]} elements - List of HTML elements to convert.
+   * @param {VegaRTETransformOptions} options - Options for transformation.
+   * @returns {RTEListBlock} - List block DTO.
+   */
+  generateWithListBlock(elements, options) {
+    return RTEListBlock.from({
+      id: generateUUID(),
+      type: 'bullet-list',
+      blocks: elements.map((item) => {
+        return this.generateListItemBlockDTO(item, options);
+      }),
+    }, options);
+  }
+  /**
+   * Generate list item block DTO from an HTML element.
+   *
+   * @param {HTMLElement} element - HTML element to convert.
+   * @param {VegaRTETransformOptions} options - Options for transformation.
+   * @returns {VegaRTEListItemBlock} - List item block DTO.
+   */
+  generateListItemBlockDTO(element, options) {
+    return {
+      id: generateUUID(),
+      type: 'list-item',
+      annotations: htmlElementToAnnotationGenerator.generate(RTEListItemBlock, element, options),
+      nodes: this.generateChildNodes(Array.from(element.childNodes.length ? element.childNodes : [element]).filter((item) => {
+        return !['UL', 'OL'].includes(item.nodeName);
+      }), htmlElementToAnnotationGenerator.generate(RTETextNode, element, Object.assign(Object.assign({}, options), { skipCustomAnnotations: true })), options),
+    };
+  }
 }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/ol-to-rte-list-block-strategy.js

@@ -1,6 +1,8 @@
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTEListBlock } from '../../../../dto/blocks/list-block';
+import { RTEListItemBlock } from '../../../../dto/blocks/list-item-block';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 /** Transform ol element to list block DTO */
 export class OlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   /**
@@ -17,26 +19,27 @@ export class OlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    * Parse to a number list block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Number list block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     if (elementsArray[0].childNodes.length === 0)
       return null;
     return RTEListBlock.from({
       id: generateUUID(),
       type: 'number-list',
       blocks: [],
-      annotations: this.generateBlockAnnotations(elementsArray[0]),
-    });
+      annotations: htmlElementToAnnotationGenerator.generate(RTEListBlock, elementsArray[0], options),
+    }, options);
   }
   /**
    * Append child list item blocks to current list block.
    *
    * @param {RTEListBlock} currentBlock - Current list block.
-   * @param {RTEListItemBlock[]} childBlocks - Current list item blocks.
+   * @param {RTEContentBlock[]} childBlocks - Current list item blocks.
    */
   appendChildBlocks(currentBlock, childBlocks) {
-    currentBlock.children = childBlocks;
+    currentBlock.children = childBlocks.filter((block) => block instanceof RTEListItemBlock);
     childBlocks.forEach((block) => (block.parent = currentBlock));
   }
   /**

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

@@ -0,0 +1,35 @@
+import { cleanObject } from '../../../../../../utils/object';
+import { RTETextNode } from '../../../../dto/nodes/text-node';
+import { ElementToTextNodeStrategy } from './element-to-text-node-strategy';
+/**
+ * Class to handle plain text nodes and convert them to RTE text node DTOs
+ */
+export class PlainTextToTextNodeStrategy extends ElementToTextNodeStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    return element.nodeType === Node.TEXT_NODE ? 1 : 0;
+  }
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray, options, parentTextAnnotations) {
+    const parentAnnotations = Object.assign({}, parentTextAnnotations);
+    const disableAutoMatchFormat = !!(options && options.autoMatchFormat === false);
+    const child = elementsArray[0];
+    const parentNodeName = child.parentNode.nodeName.toLowerCase();
+    const plainText = disableAutoMatchFormat && !RTETextNode.supportsHtmlTag(parentNodeName);
+    const textNode = this.generateTextNode(String(child.textContent), disableAutoMatchFormat
+      ? cleanObject(Object.assign(Object.assign({}, (parentNodeName === 'span'
+        ? parentAnnotations
+        : {
+          // text node could be wrapped in <a> tag, so we need to keep the parent link annotation
+          link: parentAnnotations.link,
+          code: parentNodeName === 'code' ? parentAnnotations.code : undefined,
+        })), { inlineHtml: parentAnnotations.inlineHtml, plainText: plainText || undefined }))
+      : parentAnnotations);
+    return Object.assign({}, textNode);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/span-img-to-rte-image-block-strategy.js

@@ -1,8 +1,6 @@
-import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
-import { generateUUID } from '../../../../../../utils/misc';
-import { RTEImageBlock } from '../../../../dto/blocks/image-block';
+import { ElementToRTEImageBlockStrategyAbstract } from './element-to-rte-image-block-strategy.abstract';
 /** Transform img in span or other inline element to image block DTO */
-export class SpanImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+export class SpanImageToRTEImageBlockStrategy extends ElementToRTEImageBlockStrategyAbstract {
   /**
    * Can be handle.
    *
@@ -22,26 +20,12 @@ export class SpanImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbs
    * Parse to a image block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Image block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     const element = elementsArray[0].querySelector('img');
-    return RTEImageBlock.from({
-      id: generateUUID(),
-      type: 'image',
-      nodes: [
-        {
-          id: generateUUID(),
-          type: 'image',
-          url: element.src,
-          annotations: {
-            size: 'md',
-            alt: element.alt,
-          },
-        },
-      ],
-      annotations: this.generateBlockAnnotations(element),
-    });
+    return this.createRTEImageBlock(element, options);
   }
   /* istanbul ignore next */
   /**

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

@@ -1,3 +1,4 @@
+import { isNonNullable } from '../../../../../../types/type-guard';
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTEListItemBlock } from '../../../../dto/blocks/list-item-block';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
@@ -13,24 +14,28 @@ export class ULNotLiChildToRTEListItemBlockStrategy extends BlockToRTEBlockStrat
   canHandle(elementsArray, currentIndex) {
     const element = elementsArray[currentIndex];
     const parent = element.parentElement;
-    return element.nodeName !== 'LI' && parent && ['UL', 'OL'].includes(parent.nodeName) ? 1 : 0;
+    const isLiNode = element.nodeName !== 'LI';
+    // while child is empty text node like newline or empty string, we should not covert it.
+    const isEmptyNode = element.nodeType === Node.TEXT_NODE && element.textContent.trim() === '';
+    // The node must be in list item.
+    const isInList = isNonNullable(parent) && ['UL', 'OL'].includes(parent.nodeName);
+    return isLiNode && !isEmptyNode && isInList ? 1 : 0;
   }
   /**
    * Parse to a list item block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - List item block.
    */
-  handle(elementsArray) {
-    const nodes = this.generateChildNodes(elementsArray);
-    if (nodes.length === 0)
-      return null;
+  handle(elementsArray, options) {
+    const nodes = this.generateChildNodes(elementsArray, {}, options);
     return RTEListItemBlock.from({
       id: generateUUID(),
       type: 'list-item',
       nodes: nodes,
       annotations: {},
-    });
+    }, options);
   }
   /* istanbul ignore next */
   /**

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

@@ -1,6 +1,8 @@
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTEListBlock } from '../../../../dto/blocks/list-block';
+import { RTEListItemBlock } from '../../../../dto/blocks/list-item-block';
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
 /** Transform ul element to list block DTO */
 export class UlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   /**
@@ -17,26 +19,27 @@ export class UlToRTEListBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    * Parse to a block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Bullet list block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     if (elementsArray[0].childNodes.length === 0)
       return null;
     return RTEListBlock.from({
       id: generateUUID(),
       type: 'bullet-list',
       blocks: [],
-      annotations: this.generateBlockAnnotations(elementsArray[0]),
-    });
+      annotations: htmlElementToAnnotationGenerator.generate(RTEListBlock, elementsArray[0], options),
+    }, options);
   }
   /**
    * Append child list item blocks to current list block.
    *
    * @param {RTEListBlock} currentBlock - Current list block.
-   * @param {RTEListItemBlock[]} childBlocks - Current list item blocks.
+   * @param {RTEContentBlock[]} childBlocks - Current list item blocks.
    */
   appendChildBlocks(currentBlock, childBlocks) {
-    currentBlock.children = childBlocks;
+    currentBlock.children = childBlocks.filter((block) => block instanceof RTEListItemBlock);
     childBlocks.forEach((block) => (block.parent = currentBlock));
   }
   /**

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

@@ -1,9 +1,11 @@
 import { generateUUID } from '../../../../../../utils/misc';
 import { RTEImageBlock } from '../../../../dto/blocks/image-block';
-import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
 import { isNonNullable } from '../../../../../../types/type-guard';
+import { ElementToRTEImageBlockStrategyAbstract } from './element-to-rte-image-block-strategy.abstract';
+import htmlElementToAnnotationGenerator from './annotation-handler/html-element-to-annotation-generator';
+import { RTEImageNode } from '../../../../dto/nodes/image-node';
 /** Transform vega-rich-text-image-editor element to image block DTO */
-export class VegaImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+export class VegaImageToRTEImageBlockStrategy extends ElementToRTEImageBlockStrategyAbstract {
   /**
    * Can be handle.
    *
@@ -18,9 +20,10 @@ export class VegaImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbs
    * Parse to a image block.
    *
    * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
    * @returns {Nullable<RTEContentBlock>} - Image block.
    */
-  handle(elementsArray) {
+  handle(elementsArray, options) {
     const element = elementsArray[0];
     const image = element.querySelector('img');
     if (isNonNullable(image)) {
@@ -32,14 +35,11 @@ export class VegaImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbs
             id: generateUUID(),
             type: 'image',
             url: image.src,
-            annotations: {
-              size: element.size || 'md',
-              alt: element.alt,
-            },
+            annotations: htmlElementToAnnotationGenerator.generate(RTEImageNode, element, options),
           },
         ],
-        annotations: this.generateBlockAnnotations(element),
-      });
+        annotations: htmlElementToAnnotationGenerator.generate(RTEImageBlock, element.parentElement, options),
+      }, options);
     }
   }
   /* istanbul ignore next */

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/base-handler.js

@@ -2,7 +2,7 @@ import changeManager from '../../../../../../helpers/change-manager/change-manag
 import domNodeSubjectFactory from '../../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import { VegaInternalRichTextEditDeleteSelectedNodes } from '../../../../../../helpers/event-manager/event-id/vega-internal-event-id';
 import { generateUUID } from '../../../../../../utils/misc';
-import { AppendChildNodesAction } from '../../../../dto/actions/append-child-nodes-action';
+import { AppendChildrenAction } from '../../../../dto/actions/append-child-nodes-action';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
 import { RTETextNode } from '../../../../dto/nodes/text-node';
 const ROOT_CONTAINER_CLASS_NAME = 'rich-text-content';
@@ -62,7 +62,7 @@ export class BaseHandler {
   createEmptyParagraph() {
     const paragraph = new RTETextBlock(generateUUID(), 'paragraph');
     const textNode = new RTETextNode(`${paragraph.id}1`, '', paragraph);
-    paragraph.apply(new AppendChildNodesAction([textNode]));
+    paragraph.apply(new AppendChildrenAction([textNode]));
     return paragraph;
   }
   /**

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/delete-content-handler.js

@@ -1,7 +1,7 @@
-import { AppendChildNodesAction } from '../../../../dto/actions/append-child-nodes-action';
+import { AppendChildrenAction } from '../../../../dto/actions/append-child-nodes-action';
 import { DeleteBlockContentAction } from '../../../../dto/actions/delete-block-content-action';
-import { InsertBlocksBeforeAction } from '../../../../dto/actions/insert-blocks-before-block';
-import { RemoveChildAction } from '../../../../dto/actions/remove-child-action';
+import { InsertChildrenBeforeAction } from '../../../../dto/actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../../../dto/actions/remove-child-action';
 import { ReplaceChildNodesAction } from '../../../../dto/actions/replace-child-nodes-action';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
 import { RTETextNode } from '../../../../dto/nodes/text-node';
@@ -37,7 +37,7 @@ export class DeleteContentHandler extends BaseHandler {
       if (deleteAction.previousNode) {
         const nextOffset = deleteAction.previousNode === selectedNodes[0]
           ? Math.max(0, startOffset - 1)
-          : this.getNodeEndOffset(deleteAction.previousNode);
+          : deleteAction.previousNode.getRangeEndOffset();
         this.selectionController.enqueueSelectionRangeFutureState(deleteAction.previousNode, nextOffset);
       }
       else if (deleteAction.nextNode) {
@@ -59,7 +59,7 @@ export class DeleteContentHandler extends BaseHandler {
     if (selectedNodes.length > 1 &&
       lastSelectedNode instanceof RTETextNode &&
       lastSelectedNode.isEmpty()) {
-      lastSelectedNode.parent.apply(new RemoveChildAction(lastSelectedNode));
+      lastSelectedNode.parent.apply(new RemoveChildrenAction(lastSelectedNode));
     }
     this.convertFirstBlockToParagraph(cursorNode.parent);
   }
@@ -77,8 +77,8 @@ export class DeleteContentHandler extends BaseHandler {
       block.type !== 'paragraph') {
       const paragraph = this.createEmptyParagraph();
       paragraph.apply(new ReplaceChildNodesAction(block.children));
-      block.parent.apply(new InsertBlocksBeforeAction(block, paragraph));
-      block.parent.apply(new RemoveChildAction(block));
+      block.parent.apply(new InsertChildrenBeforeAction(block, paragraph));
+      block.parent.apply(new RemoveChildrenAction(block));
     }
   }
   /**
@@ -86,21 +86,7 @@ export class DeleteContentHandler extends BaseHandler {
    */
   insertDefaultParagraph() {
     const paragraph = this.createEmptyParagraph();
-    this.currentState.apply(new AppendChildNodesAction([paragraph]));
+    this.currentState.apply(new AppendChildrenAction([paragraph]));
     this.selectionController.enqueueSelectionRangeFutureState(paragraph.children[0], 1);
   }
-  /**
-   * Returns the end offset of a given node in a Rich Text Editor based on its type and text content.
-   *
-   * @param {RTENode} node - text node or image node
-   * @returns {number} Returns a number value.
-   */
-  getNodeEndOffset(node) {
-    if (node.type === 'IMAGE') {
-      return 1;
-    }
-    else if (node.type === 'TEXT') {
-      return node['text'] === '\n' ? 0 : node['text'].length;
-    }
-  }
 }

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paragraph-handler.js

@@ -1,7 +1,7 @@
 import { BaseHandler } from './base-handler';
 import { SplitBlockWithNodeAction } from '../../../../dto/actions/split-block-with-node-action';
 import { MergeTwoBlocksNodesAction } from '../../../../dto/actions/merge-two-blocks-nodes-action';
-import { BreakSingleBlockAction } from '../../../../dto/actions/break-single-block-action';
+import { InsertNewParagraphAction } from '../../../../dto/actions/insert-new-paragraph-action';
 /** Insert a paragraph in a rich text editor based on the current selection and event. User type enter will trigger this callback */
 export class InsertParagraphHandler extends BaseHandler {
   /**
@@ -74,7 +74,7 @@ export class InsertParagraphHandler extends BaseHandler {
     const currentBlock = cursorNode.parent;
     const { startOffset } = this.selectionController.getCurrentRange();
     if (currentBlock) {
-      const breakAction = new BreakSingleBlockAction(cursorNode, startOffset);
+      const breakAction = new InsertNewParagraphAction(cursorNode, startOffset);
       currentBlock.apply(breakAction);
       this.switchCaretPositionToNextElement(breakAction.newBlock);
     }