@globalpayments/vega 2.34.0 → 2.35.0

package/dist/types/components/vega-rich-text-editor/dto/blocks/text-block.d.ts

@@ -1,4 +1,4 @@
-import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, RTERenderContext, VegaRTETextStyleType } from '../../interface';
+import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { Nullable } from '../../../../types/general';
 import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
@@ -16,8 +16,13 @@ export declare class RTETextBlock extends RTEBlock {
   nodes: RTETextNode[];
   parent: VegaRTEContent | RTEListBlock;
   constructor(id: string, type: VegaRTETextBlockType);
+  /**
+   * Converts a VegaRTETextBlock into an RTETextBlock.
+   *
+   * @param {VegaRTETextBlock} block - The block object
+   * @returns {RTETextBlock} A RTETextBlock class
+   */
   static from(block: VegaRTETextBlock): RTETextBlock;
-  static fromHTML(node: HTMLElement, blockType: VegaRTETextBlockType): RTETextBlock;
   /**
    * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
    * and value.
@@ -31,15 +36,41 @@ export declare class RTETextBlock extends RTEBlock {
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
   protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations | 'textStyle', value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  /**
+   * Checks if a given text block type is one of the acceptable text styles.
+   *
+   * @param {VegaRTETextBlockType} type - The text block type
+   * @returns {boolean} Return a boolean value indicating whether the `type` parameter is valid.
+   */
   protected static isAcceptableTextStyle(type: VegaRTETextBlockType): type is VegaRTETextStyleType;
+  /**
+   * Merges RTETextNode nodes based on certain conditions.
+   *
+   * @param {AnnotationAction} action - AnnotationAction
+   */
   mergeNodes(action: AnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTETextBlock;
+  /**
+   * Clone the nodes to a new block
+   *
+   * @param {RTEBlock} nodes - The nodes will be copied
+   * @returns {RTEBlock} New block
+   */
   cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext, children?: Nullable<HTMLElement[]>): HTMLElement;
-  protected registerRef(ref: Nullable<HTMLElement>): void;
-  protected renderNodes(renderConfig?: RTERenderContext): HTMLElement[];
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: AnnotationAction): void;
   /**
    * Apply a modify action to block
@@ -47,17 +78,90 @@ export declare class RTETextBlock extends RTEBlock {
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Splits a text node at a specified offset within a block of nodes and returns a new block with the split nodes.
+   *
+   * @param {RTETextNode} splitNode - The text node that will be split
+   * @param {number} startOffsetOfNode - The index at which will split the text content of the `splitNode`.
+   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
+   */
   protected splitTextNodeBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTEBlock>;
+  /**
+   * Checks if the caret position is at the start of a specified RTETextNode.
+   *
+   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
+   * @param {number} startOffset - The position within the text node where the caret is located.
+   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
+   */
   protected isCaretPositionAtStart(node: RTETextNode, startOffset: number): boolean;
+  /**
+   * Checks if the caret position is at the end of a specified RTETextNode.
+   *
+   * @param {RTETextNode} node - `RTETextNode` - a node representing an image in a rich text editor.
+   * @param {number} startOffset - The position within the text node where the caret is located.
+   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTETextNode.
+   */
   protected isCaretPositionAtEnd(node: RTETextNode, startOffset: number): boolean;
+  /**
+   * lineBreakSingleBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
   protected lineBreakSingleBlock(splitNode: RTETextNode, startOffsetOfNode: number): Nullable<RTETextNode>;
+  /**
+   * lineBreakMultipleBlocks
+   *
+   * @param {RTEBlock[]} selectedBlocks -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
   protected lineBreakMultipleBlocks(selectedBlocks: RTEBlock[]): Nullable<RTETextNode>;
+  /**
+   * deleteNodeContent
+   *
+   * @param {DeleteBlockContentAction} action - ModifyContentAction
+   */
   protected deleteNodeContent(action: DeleteBlockContentAction): void;
+  /**
+   * Remove the child node
+   *
+   * @param {RemoveChildAction} action - Modify action
+   */
   private removeChildNode;
+  /**
+   * mergeLineBreakNodes
+   *
+   * @param {RTENode[]} beforeNodes -
+   * @param {RTETextNode} lineBreakNode -
+   * @param {RTENode[]} afterNodes -
+   */
   private mergeLineBreakNodes;
-  private getBlockTagByType;
+  /**
+   * breakSingleTextBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
+   */
   private breakSingleTextBlock;
+  /**
+   * convertParagraphToList
+   *
+   * @param {TransformListAction} action - ModifyContentAction
+   */
   private convertParagraphToList;
+  /**
+   * insertImage
+   *
+   * @param {InsertImageToBlockAction} action - ModifyContentAction
+   */
   private insertImage;
+  /**
+   * copyInlineStyleToNewParagraph
+   *
+   * @param {RTETextNode} needCopedNode -
+   * @returns {RTETextBlock} RTETextBlock
+   */
   private copyInlineStyleToNewParagraph;
 }

package/dist/types/components/vega-rich-text-editor/dto/nodes/image-node.d.ts

@@ -1,19 +1,34 @@
 import { NodeTypeEnum, RTENode } from './node.abstract';
 import { RTEImageBlock } from '../blocks/image-block';
-import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEImageNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEImageNode } from '../../interface';
 import { ImageAnnotationAction } from '../actions/image-annotation-action';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
+/**
+ * Image node
+ */
 export declare class RTEImageNode extends RTENode {
   readonly type: NodeTypeEnum;
   parentBlock: RTEImageBlock;
   url: string;
   constructor(id: string, url: string, parentBlock: RTEImageBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
-  static from(image: VegaRTEImageNode, parentBlock: RTEImageBlock): RTEImageNode;
-  static fromHTML(node: HTMLImageElement | HTMLVegaRichTextImageEditorElement, parentBlock: RTEImageBlock): RTEImageNode;
+  /**
+   * Converts a VegaRTEImageNode into an RTEImageNode by mapping nodes and creating annotations.
+   *
+   * @param {VegaRTEImageNode} node - The node to be converted.
+   * @param {RTEImageBlock} parentBlock - The parent block
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
+   */
+  static from(node: VegaRTEImageNode, parentBlock: RTEImageBlock): RTEImageNode;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEImageNode;
-  render({ editable }?: RTERenderContext): HTMLElement;
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: ImageAnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
-  private renderImage;
 }

package/dist/types/components/vega-rich-text-editor/dto/nodes/node.abstract.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationStyle, RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, RTERenderContext, VegaRTEBaseNode } from '../../interface';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTEBaseNode } from '../../interface';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { RTEBlock } from '../blocks/block.abstract';
 import { Nullable } from '../../../../types/general';
@@ -36,25 +36,12 @@ export declare abstract class RTENode {
    * @returns {this} - Node
    */
   apply(action: AnnotationAction | ModifyContentAction): this;
-  abstract render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * apply annotation action or modify content action
    *
    * @param {AnnotationAction | ModifyContentAction} action annotation type action or modify content type action
    */
   protected doApply(action: AnnotationAction | ModifyContentAction): void;
-  /**
-   * Get styles from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getStyles(): AnnotationStyle;
-  /**
-   * Get classes from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getClasses(): string;
   /**
    * Flush the value change
    */

package/dist/types/components/vega-rich-text-editor/dto/nodes/text-node.d.ts

@@ -6,28 +6,110 @@ import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 export declare type Link = {
   href?: string;
 };
+/**
+ * Text node
+ */
 export declare class RTETextNode extends RTENode {
   readonly type: NodeTypeEnum;
   text: string;
   parentBlock: RTETextBlock;
   constructor(id: string, text: string, parentBlock: RTETextBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * Creates an RTETextNode from a VegaRTETextNode with annotations and a parent RTETextBlock.
+   *
+   * @param {VegaRTETextNode} richText - A rich text node
+   * @param {RTETextBlock} parentBlock - Parent block
+   * @returns {RTETextNode} an RTETextNode
+   */
   static from(richText: VegaRTETextNode, parentBlock: RTETextBlock): RTETextNode;
-  static fromHTML(node: HTMLElement, parentBlock: RTETextBlock): RTETextNode;
+  /**
+   * Creates different types of text annotations based on the provided type and value.
+   *
+   * @param {keyof VegaRTETextAnnotations} type - The key of the type.
+   * @param {unknown} value - The value that will be used to create the specific type of annotation entity based on the `type` provided.
+   * @returns {Nullable<[RTENodeAnnotationMapKey, RTENodeAnnotationMapValue]>} Returning a nullable tuple containing a key and a
+   * value from the `RTENodeAnnotationMapKey` and `RTENodeAnnotationMapValue` types.
+   */
   private static createAnnotationEntity;
-  private static createAnnotationEntityFromHTML;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTETextNode;
+  /**
+   * Creates a new RTETextNode with the specified text and copies the parent block and annotation map from the original node.
+   *
+   * @param {string} text - The text content of the RTETextNode that will be created.
+   * @returns {RTETextNode} An new RTETextNode
+   */
   cloneWithText(text: string): RTETextNode;
+  /**
+   * Checks if a node is empty
+   *
+   * @returns {boolean}  It returns `true` if the node is empty
+   */
   isEmpty(): boolean;
-  render(): HTMLElement;
+  /**
+   * @inheritDoc
+   */
   protected doAnnotationActionApply(action: AnnotationAction): void;
+  /**
+   * @inheritDoc
+   */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
+  /**
+   * Split text node with range
+   *
+   * @param {TextSplittableAction} action - Annotation action
+   * @param {Range} range - Selection range
+   * @returns {RTETextNode[] | this} RTETextNode array
+   */
   private splitTextNode;
+  /**
+   * Apply action to node
+   *
+   * @param {RTETextNode} node - Text node
+   * @param {AnnotationAction} action - AnnotationAction
+   */
   private applyActionToNode;
+  /**
+   * 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).
+   */
   private replaceSelectedText;
+  /**
+   * 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
+   */
   private updateText;
+  /**
+   * Checks if a node has an annotation with the key 'LINK'.
+   *
+   * @returns {boolean} A boolean value indicating whether the `annotationMap` has a key 'LINK'.
+   */
   private isLinkNode;
+  /**
+   * 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.
+   */
   private shouldSplitSelection;
+  /**
+   * Sync up the selected node by change manager
+   *
+   * @param {RTETextNode} selectedNode - The selected node
+   */
   private syncUpSelectedNodes;
+  /**
+   * Insert the new node at the start offset
+   *
+   * @param {number} startOffset - The start position offset
+   * @param {AnnotationAction} action - AnnotationAction
+   * @returns {RTETextNode[]} - RTETextNode array
+   */
   private insertNewNode;
 }

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/block-renderer.abstract.d.ts

@@ -0,0 +1,28 @@
+import { RTEBlock } from '../../blocks/block.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare abstract class RTEBlockRenderer {
+  /**
+   * Check whether the block can be handled by this renderer
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {boolean} - can be handled or not
+   */
+  canHandle?(block: RTEBlock): boolean;
+  abstract render(block: RTEBlock, renderContext: RTERenderContext): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, block: RTEBlock): void;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getStyles(block: RTEBlock): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTEBlock} block - RTE block entity
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getClasses(block: RTEBlock): string;
+}

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/block-text-nodes-renderer.abstract.d.ts

@@ -0,0 +1,14 @@
+import { RTERenderContext } from '../../../interface';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+/**
+ * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
+ */
+export declare abstract class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
+  protected renderNodes(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement[];
+  private renderLinkNodes;
+  private groupNodesByLink;
+  private isLinkGroup;
+  private renderLinkEditorWrapper;
+  private renderLink;
+}

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/image-block-renderer.d.ts

@@ -0,0 +1,10 @@
+import { RTEImageBlock } from '../../blocks/image-block';
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlock } from '../../blocks/block.abstract';
+declare class RTEImageBlockRenderer extends RTEBlockRenderer {
+  canHandle(block: RTEBlock): boolean;
+  render(block: RTEImageBlock, renderContext: RTERenderContext): HTMLElement;
+}
+declare const _default: RTEImageBlockRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-block-renderer.d.ts

@@ -0,0 +1,10 @@
+import { RTEBlockRenderer } from './block-renderer.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlock } from '../../blocks/block.abstract';
+declare class RTEListBlockRenderer extends RTEBlockRenderer {
+  canHandle(block: RTEBlock): boolean;
+  render(block: RTEListBlock, renderContext: RTERenderContext): HTMLElement;
+}
+declare const _default: RTEListBlockRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-item-block-renderer.d.ts

@@ -0,0 +1,9 @@
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { RTERenderContext } from '../../../interface';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+declare class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  render(block: RTEListItemBlock, renderContext: RTERenderContext): HTMLElement;
+  private renderChildren;
+}
+declare const _default: RTEListItemBlockRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/text-block-renderer.d.ts

@@ -0,0 +1,11 @@
+import { RTERenderContext } from '../../../interface';
+import { RTETextBlock } from '../../blocks/text-block';
+import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
+import { RTEBlock } from '../../blocks/block.abstract';
+declare class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  canHandle(block: RTEBlock): boolean;
+  render(block: RTETextBlock, renderContext: RTERenderContext): HTMLElement;
+  private getBlockTagByType;
+}
+declare const _default: RTETextBlockRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/image-node-renderer.d.ts

@@ -0,0 +1,10 @@
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { RTEImageNode } from '../../nodes/image-node';
+import { RTERenderContext } from '../../../interface';
+declare class RTEImageNodeRenderer extends RTENodeRenderer {
+  render(node: RTEImageNode, renderContext: RTERenderContext): HTMLElement;
+  private renderImage;
+  private handleChange;
+}
+declare const _default: RTEImageNodeRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/node-renderer.abstract.d.ts

@@ -0,0 +1,21 @@
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../nodes/node.abstract';
+export declare abstract class RTENodeRenderer {
+  abstract render(node: RTENode, renderContext?: RTERenderContext): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, node: RTENode): void;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getStyles(node: RTENode): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTENode} node - The DTO node
+   * @returns {AnnotationStyle} - Annotation style
+   */
+  protected getClasses(node: RTENode): string;
+}

package/dist/types/components/vega-rich-text-editor/dto/renderers/nodes/text-node-renderer.d.ts

@@ -0,0 +1,9 @@
+import { RTENodeRenderer } from './node-renderer.abstract';
+import { RTETextNode } from '../../nodes/text-node';
+import { Nullable } from '../../../../../types/general';
+declare class RTETextNodeRenderer extends RTENodeRenderer {
+  render(node: RTETextNode): HTMLElement;
+  protected registerRef(ref: Nullable<HTMLElement>, node: RTETextNode): void;
+}
+declare const _default: RTETextNodeRenderer;
+export default _default;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract.d.ts

@@ -0,0 +1,111 @@
+import { VegaRTEBlockAnnotations, VegaRTETextAnnotations, VegaRTETextNode } from '../../../../interface';
+import { ElementToDTOStrategy } from './element-to-dto-strategy.abstract';
+/** Abstract class for block html element to RTE block dto */
+export declare abstract class BlockToRTEBlockStrategyAbstract extends ElementToDTOStrategy {
+  /**
+   * Generate child nodes of block element, this will inherit all annotations from parent to text node and
+   *   flat the child nodes.
+   *
+   * Example:
+   *   <li>
+   *     <u><i>text1</i></u>
+   *     <span style='font-weight: bold;'><span>text2</span></span>
+   *     text3
+   *   </li>
+   * will tranform to:
+   *   <li>
+   *     <span>text1</span> // with underline and italic annotations
+   *     <span>text2</span> // with bold annotations
+   *     <span>text3</span> // no annotations
+   *   </li>
+   *
+   * @param {HTMLElement[]} elements - Child elements.
+   * @param {HTMLElement[]} annotations - Parent annotations.
+   * @returns {VegaRTETextNode[]} - Text node DTO.
+   */
+  protected generateChildNodes(elements: HTMLElement[], annotations?: VegaRTETextAnnotations): VegaRTETextNode[];
+  /**
+   * Generate annotations map for block element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {VegaRTEBlockAnnotations} - Text block annotations.
+   */
+  protected generateBlockAnnotations(element: HTMLElement): VegaRTEBlockAnnotations;
+  /**
+   * Check is a invalid text node.
+   *
+   * @param {HTMLElement} element - Current node element.
+   * @returns {boolean} - boolean.
+   */
+  private isInvalidTextNode;
+  /**
+   * Generate annotations map for text node element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {VegaRTETextAnnotations | VegaRTECodeAnnotations} - Text node annotations.
+   */
+  private generateTextNodeAnnotations;
+  /**
+   * Is code element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isCode;
+  /**
+   * Is bold element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isBold;
+  /**
+   * Is italic element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isItalic;
+  /**
+   * Is underline element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isUnderline;
+  /**
+   * Is strikethrough element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {boolean} - boolean.
+   */
+  private isStrikethrough;
+  /**
+   * Get current color of element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<string>} - color.
+   */
+  private getColor;
+  /**
+   * Get current link of element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRTELink>} - link.
+   */
+  private getLink;
+  /**
+   * Get text align of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<VegaRTEBlockAlignment>} - Text align.
+   */
+  private getTextAlign;
+  /**
+   * Get indent of current element.
+   *
+   * @param {HTMLElement} element - current element.
+   * @returns {Nullable<number>} - Indent.
+   */
+  private getIndent;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.d.ts

@@ -0,0 +1,32 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
+/** Transform continue inline block elements to text block DTO */
+export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  private static canHandleTags;
+  /**
+   * Can be handle.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {number} currentIndex - Current element index.
+   * @returns {number} - can be handled element count.
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * Parse to a text block.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @returns {Nullable<RTEContentBlock>} - Text block.
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<RTEContentBlock>;
+  /**
+   * Append child blocks.
+   */
+  appendChildBlocks(): void;
+  /**
+   * Should continue process to child elements.
+   *
+   * @returns {boolean} - boolean.
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.d.ts

@@ -0,0 +1,19 @@
+import { ElementToDTOStrategyOutput } from './element-to-dto-strategy.abstract';
+/** Element to DTO processor */
+export declare class ElementToDtoStrategyProcessor {
+  private elementStrategies;
+  /**
+   * Transform process.
+   *
+   * @param {HTMLElement[]} elements - Current elements.
+   * @returns {ElementToDTOStrategyOutput[]} - outputs.
+   */
+  process(elements: HTMLElement[]): ElementToDTOStrategyOutput[];
+  /**
+   * Checks if the given element is valid to parse.
+   *
+   * @param {HTMLElement} element - The pasted element.
+   * @returns {boolean} Is valid
+   */
+  private isInvalidElement;
+}