@globalpayments/vega 2.34.0 → 2.35.0

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

@@ -1,10 +1,7 @@
-import { h } from '@stencil/core';
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
-import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { RemoveChildAction } from '../actions/remove-child-action';
-import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { isNonNullable } from '../../../../types/type-guard';
 import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { ReplaceChildNodesAction } from '../actions/replace-child-nodes-action';
@@ -23,6 +20,12 @@ export class RTEImageBlock extends RTEBlock {
     this.type = 'image';
     this.nodes = [];
   }
+  /**
+   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
+   *
+   * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
+   */
   static from(block) {
     const imageBlock = new RTEImageBlock(block.id);
     const { annotations } = block;
@@ -37,34 +40,26 @@ export class RTEImageBlock extends RTEBlock {
     }
     return imageBlock;
   }
-  static fromHTML(node) {
-    const nodes = node.nodeName === 'IMG' ? [node] : Array.from(node.children);
-    const imageBlock = new RTEImageBlock(generateUUID());
-    imageBlock.nodes = nodes.map((item) => RTEImageNode.fromHTML(item, imageBlock));
-    Object.keys(BlockAnnotationTypeEnum).forEach((type) => {
-      const item = this.createAnnotationEntityFromHTML(type, node);
-      if (isNonNullable(item)) {
-        imageBlock.annotationMap.set(...item);
-      }
-    });
-    return imageBlock;
-  }
+  /**
+   * @inheritDoc
+   */
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { type: 'image', nodes: this.nodes.map((node) => node.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
   isNotEmpty() {
     return this.nodes.length > 0 && this.nodes.some((node) => node.url.length > 0);
   }
+  /**
+   * @inheritDoc
+   */
   getLastNode() {
     return this.nodes[this.nodes.length - 1];
   }
-  render(renderContext) {
-    return (h("div", { style: Object.assign({}, this.getStyles()), ref: this.registerRef.bind(this), class: super.getClasses() }, this.nodes.map((node) => {
-      return node.render(renderContext);
-    })));
-  }
   /**
-   * Apply modify action to block
+   * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
@@ -118,11 +113,11 @@ export class RTEImageBlock extends RTEBlock {
         break;
     }
   }
-  registerRef(ref) {
-    if (ref) {
-      stateEntityRenderingRegistry.register(ref, this);
-    }
-  }
+  /**
+   * Removes a specified child node from a list of nodes and triggers a parent action if the list becomes empty.
+   *
+   * @param {RemoveChildAction} action - Action to be performed when removing a child node from the list of nodes.
+   */
   removeChildNode(action) {
     this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
     if (this.nodes.length === 0) {
@@ -135,6 +130,7 @@ export class RTEImageBlock extends RTEBlock {
    *
    * @param {RTEImageNode} imageNode The split point image node
    * @param {number} imageOffset The cursor point 0 | 1
+   * @returns {Nullable<RTEBlock>} The new block after split
    */
   splitImageNodes(imageNode, imageOffset) {
     const nodesSplitIndex = this.nodes.indexOf(imageNode);
@@ -147,12 +143,25 @@ export class RTEImageBlock extends RTEBlock {
       return newBlock;
     }
   }
+  /**
+   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
+   *
+   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   */
   cloneWithNodes(nodes) {
     const block = new RTEImageBlock(generateUUID());
     block.nodes = [];
     block.apply(new AppendChildNodesAction(nodes));
     return block;
   }
+  /**
+   * Used to split a block of text at a specific position and insert a new paragraph block.
+   *
+   * @param {RTEImageNode} splitNode - The node that needs to be split into separate blocks.
+   * @param {number} startOffsetOfNode - The index or position within the `splitNode` where the block should be broken or split.
+   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
+   */
   breakSingleBlock(splitNode, startOffsetOfNode) {
     const newParagraph = RTETextBlock.from({
       id: generateUUID(),
@@ -172,19 +181,46 @@ export class RTEImageBlock extends RTEBlock {
     }
     return newParagraph;
   }
+  /**
+   * Breaks a single block of text at a specified offset and returns the first node of the new paragraph if created.
+   *
+   * @param {RTEImageNode} splitNode - It represents a node in a rich text editor that contains an image.
+   * @param {number} startOffset - The index at which the line break should occur within the `RTEImageNode` block.
+   * @returns {Nullable<RTETextNode>} Returning the first node of the `newParagraph` block if `newParagraph` is not null.
+   */
   lineBreakSingleBlock(splitNode, startOffset) {
     const newParagraph = this.breakSingleBlock(splitNode, startOffset);
     if (newParagraph) {
       return newParagraph['nodes'][0];
     }
   }
+  /**
+   * Checks if the caret position is at the start of a specified RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `RTEImageNode` - a node representing an image in a rich text editor.
+   * @param {number} startOffset - The position within the text node where the caret is located.
+   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTEImageNode.
+   */
   isCaretPositionAtStart(node, startOffset) {
     return node === this.nodes[0] && startOffset === 0;
   }
+  /**
+   * Checks if the caret position is at the end of a given RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `node` is a RTEImageNode
+   * @param {number} startOffset - The position within the `RTEImageNode` where the caret is located.
+   * @returns {boolean}Returns a boolean value indicating whether the caret position is at the end of the `RTEImageNode`.
+   */
   isCaretPositionAtEnd(node, startOffset) {
     const lastNode = this.nodes[this.nodes.length - 1];
     return node === lastNode && startOffset === 1;
   }
+  /**
+   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
+   *
+   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   */
   lineBreakMultipleBlocks(selectedBlocks) {
     const newParagraph = RTETextBlock.from({
       id: generateUUID(),
@@ -199,6 +235,11 @@ export class RTEImageBlock extends RTEBlock {
     newParagraph.apply(new AppendChildNodesAction(afterNodes));
     return newParagraph['nodes'][0];
   }
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   */
   deleteNodeContent(action) {
     const startContainerNode = action
       .startContainerNode, startOffset = action.startOffset;

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

@@ -1,7 +1,5 @@
-import { h } from '@stencil/core';
 import { RTEBlock } from './block.abstract';
 import { RTEListItemBlock } from './list-item-block';
-import stateEntityRenderingRegistry from '../../slimmers/controllers/state-entity-rendering-registry';
 import { ModifyContentActionType } from '../actions/modify-content-action.abstract';
 import { RemoveChildAction } from '../actions/remove-child-action';
 import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
@@ -11,8 +9,9 @@ import { AppendChildNodesAction } from '../actions/append-child-nodes-action';
 import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
 import { SyncUpSelectionAction } from '../actions/sync-up-selection-action';
 import { RemoveNestListAction } from '../actions/remove-nest-list-action';
-import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
-import { isNonNullable } from '../../../../types/type-guard';
+/**
+ * List block
+ */
 export class RTEListBlock extends RTEBlock {
   constructor(id, type) {
     super(id);
@@ -20,6 +19,12 @@ export class RTEListBlock extends RTEBlock {
     this.blocks = [];
     this.type = type;
   }
+  /**
+   * Converts a VegaRTEListBlock object to an RTEListBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListBlock`
+   */
   static from(block) {
     const listBlock = new RTEListBlock(block.id, block.type);
     listBlock.blocks = block.blocks.map((item) => {
@@ -29,37 +34,25 @@ export class RTEListBlock extends RTEBlock {
     });
     return listBlock;
   }
-  static fromHTML(node) {
-    const listBlock = new RTEListBlock(generateUUID(), node.nodeName === 'UL' ? 'bullet-list' : 'number-list');
-    listBlock.blocks = Array.from(node.children)
-      .map((item) => {
-      const listItemBlock = RTEListItemBlock.fromHTML(item);
-      listItemBlock && (listItemBlock.parent = listBlock);
-      return listItemBlock;
-    })
-      .filter(Boolean);
-    Object.keys(BlockAnnotationTypeEnum).forEach((type) => {
-      const item = this.createAnnotationEntityFromHTML(type, node);
-      if (isNonNullable(item)) {
-        listBlock.annotationMap.set(...item);
-      }
-    });
-    return listBlock;
-  }
+  /**
+   * @inheritDoc
+   */
   toJSON() {
     return Object.assign(Object.assign({}, super.toJSON()), { id: this.id, type: this.type, blocks: this.blocks.map((block) => block.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
   isNotEmpty() {
     return (this.blocks.length > 0 &&
       this.blocks.some((listItemBlock) => listItemBlock.isNotEmpty()));
   }
+  /**
+   * @inheritDoc
+   */
   getLastNode() {
     return this.blocks[this.blocks.length - 1].getLastNode();
   }
-  render(renderContext) {
-    const BlockTag = this.type === 'number-list' ? 'ol' : 'ul';
-    return (h(BlockTag, { ref: this.registerRef.bind(this) }, this.blocks.map((block) => block.render(renderContext))));
-  }
   /**
    * Apply a modify action to block
    *
@@ -96,17 +89,23 @@ export class RTEListBlock extends RTEBlock {
         break;
     }
   }
+  /**
+   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
+   *
+   * @param {RTEListItemBlock} block - The block that will be covered
+   * @returns {RTETextBlock} Returns a `RTETextBlock`.
+   */
   toParagraph(block) {
     const textBlock = new RTETextBlock(generateUUID(), 'paragraph');
     textBlock.apply(new AppendChildNodesAction(block['nodes']));
     textBlock['annotationMap'] = block['annotationMap'];
     return textBlock;
   }
-  registerRef(ref) {
-    if (ref) {
-      stateEntityRenderingRegistry.register(ref, this);
-    }
-  }
+  /**
+   * Covert block to List
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   convertToList(action) {
     const selectedBlocks = action.selectedBlocks;
     const bulletList = this.parent.createList(action.listType);
@@ -130,6 +129,11 @@ export class RTEListBlock extends RTEBlock {
       }
     }
   }
+  /**
+   * Covert block to paragraph
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   convertToParagraph(action) {
     let isSelectedFirstBlock = false;
     let isSelectedLastBlock = false;
@@ -165,6 +169,11 @@ export class RTEListBlock extends RTEBlock {
       this.parent.apply(new RemoveChildAction(this));
     }
   }
+  /**
+   * Inserts an image block into a rich text editor block based on the parent block type.
+   *
+   * @param {InsertImageToBlockAction} action - Modify action
+   */
   insertImage(action) {
     const imageBlock = action.imageBlockToBeInserted;
     if (this.parent['type'] !== 'list-item') {
@@ -174,10 +183,15 @@ export class RTEListBlock extends RTEBlock {
       this.parent.apply(action);
     }
   }
+  /**
+   * Removes a specified block and handles the removal of nested lists if necessary.
+   *
+   * @param {RTEBlock} blockToBeRemoved - block that will be removed
+   */
   removeListItemBlock(blockToBeRemoved) {
     super.removeChildBlock(blockToBeRemoved);
     if (this.blocks.length === 0 && this.parent) {
-      // The parent is a list item mean the current block is a nest list, so we need use RemoveNestListAction to remove the item
+      // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
       if (this.parent instanceof RTEListItemBlock) {
         this.parent.apply(new RemoveNestListAction(this));
       }

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

@@ -8,15 +8,23 @@ import { SplitBlockWithNodeAction } from '../actions/split-block-with-node-actio
 import { RTETextBlock } from './text-block';
 import { InsertBlocksAfterAction } from '../actions/insert-blocks-after-block';
 import { InsertBlocksBeforeAction } from '../actions/insert-blocks-before-block';
-import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { isNonNullable } from '../../../../types/type-guard';
 import { NodeAnnotationTypeEnum } from '../annotations/node-annotation.abstract';
+/**
+ * List item block
+ */
 export class RTEListItemBlock extends RTETextBlock {
   constructor(id, children) {
     super(id, 'list-item');
     this.children = [];
     this.children = children;
   }
+  /**
+   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListItemBlock`
+   */
   static from(block) {
     const listItemBlock = new RTEListItemBlock(block.id);
     listItemBlock.nodes = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock));
@@ -38,42 +46,25 @@ export class RTEListItemBlock extends RTETextBlock {
     }
     return listItemBlock;
   }
-  static fromHTML(node) {
-    const listItem = new RTEListItemBlock(generateUUID());
-    listItem.nodes = Array.from(node.childNodes)
-      .map((item) => {
-      if (!['UL', 'OL'].includes(item.nodeName)) {
-        return RTETextNode.fromHTML(item, listItem);
-      }
-    })
-      .filter(Boolean);
-    listItem.children = Array.from(node.childNodes)
-      .map((item) => {
-      if (['UL', 'OL'].includes(item.nodeName)) {
-        const listBlock = RTEListBlock.fromHTML(item);
-        listBlock && (listBlock.parent = listItem);
-        return listBlock;
-      }
-    })
-      .filter(Boolean);
-    Object.keys(BlockAnnotationTypeEnum).forEach((type) => {
-      const item = this.createAnnotationEntityFromHTML(type, node);
-      if (isNonNullable(item)) {
-        listItem.annotationMap.set(...item);
-      }
-    });
-    return listItem;
-  }
+  /**
+   * @inheritDoc
+   */
   toJSON() {
     var _a;
     return Object.assign(Object.assign({}, super.toJSON()), { type: 'list-item', children: (_a = this.children) === null || _a === void 0 ? void 0 : _a.map((block) => block.toJSON()) });
   }
+  /**
+   * @inheritDoc
+   */
   cloneWithNodes(nodes) {
     const block = new RTEListItemBlock(generateUUID());
     block.nodes = [];
     block.apply(new AppendChildNodesAction(nodes));
     return block;
   }
+  /**
+   * @inheritDoc
+   */
   isNotEmpty() {
     if (this.children) {
       return super.isNotEmpty() || this.children.some((block) => block.isNotEmpty());
@@ -82,6 +73,9 @@ export class RTEListItemBlock extends RTETextBlock {
       return super.isNotEmpty();
     }
   }
+  /**
+   * @inheritDoc
+   */
   getLastNode() {
     if (this.children && this.children.length > 0) {
       const childListBlock = this.children[this.children.length - 1];
@@ -89,9 +83,6 @@ export class RTEListItemBlock extends RTETextBlock {
     }
     return super.getLastNode();
   }
-  render(renderContext) {
-    return super.render(renderContext, this.renderChildren(renderContext));
-  }
   /**
    * Apply a modify action to block
    *
@@ -147,16 +138,22 @@ export class RTEListItemBlock extends RTETextBlock {
         break;
     }
   }
-  renderChildren(renderContext) {
-    var _a;
-    return (_a = this.children) === null || _a === void 0 ? void 0 : _a.map((block) => block.render(renderContext));
-  }
+  /**
+   * Remove the list child node
+   *
+   * @param {RemoveChildAction} action - Modify action
+   */
   removeListChildNode(action) {
     this.nodes = this.nodes.filter((node) => node !== action.entityToBeRemoved);
     if (this.nodes.length === 0 && (!this.children || !this.children.length)) {
       this.parent.apply(new RemoveChildAction(this));
     }
   }
+  /**
+   * Remove the nest list
+   *
+   * @param {RemoveNestListAction} action - Modify action
+   */
   removeNestList(action) {
     if (this.children) {
       if (this.children.length > 1) {
@@ -167,15 +164,34 @@ export class RTEListItemBlock extends RTETextBlock {
       }
     }
   }
+  /**
+   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
+   *
+   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
+   */
   replaceNestList(newList) {
     newList.forEach((listBlock) => {
       listBlock.parent = this;
     });
     this.children = newList;
   }
+  /**
+   * Split list item block
+   *
+   * @param {SplitBlockWithNodeAction} action - Modify action
+   */
   splitListItemBlock(action) {
     action.newBlock = this.splitTextNodeBlock(action.splitPointNode, action.startOffsetOfNode);
   }
+  /**
+   * Breaks a single list item block at a specific position.
+   *
+   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
+   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
+   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
+   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
+   * caret position if it is neither at the start nor at the end.
+   */
   breakSingleListItemBlock(splitNode, startOffsetOfNode) {
     const newListItem = new RTEListItemBlock(generateUUID());
     const newBreakNode = this.copyInlineStyleToNewNode(splitNode);
@@ -193,6 +209,12 @@ export class RTEListItemBlock extends RTETextBlock {
     }
     return newListItem;
   }
+  /**
+   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
+   *
+   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
+   */
   breakListItemAtEnd(newListItem) {
     const lastItem = this.parent.blocks[this.parent.blocks.length - 1];
     const currentItemIsEmpty = this.nodes.length === 1 && this.nodes[0].isEmpty();
@@ -219,6 +241,11 @@ export class RTEListItemBlock extends RTETextBlock {
     }
     return newListItem;
   }
+  /**
+   * Delete list node content
+   *
+   * @param {DeleteBlockContentAction} action - Modify action
+   */
   deleteListNodeContent(action) {
     const startContainerNode = action.startContainerNode;
     const listBlock = startContainerNode.parentBlock.parent;
@@ -227,9 +254,15 @@ export class RTEListItemBlock extends RTETextBlock {
       listBlock.parent.apply(new RemoveChildAction(listBlock));
     }
   }
+  /**
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
+   */
   copyInlineStyleToNewNode(needCopedNode) {
     const textNode = needCopedNode.cloneWithText('');
-    // The link annotation don't need inherited
+    // The link annotation doesn't need to inherit
     textNode.annotationMap.delete(NodeAnnotationTypeEnum.LINK);
     return textNode;
   }