@globalpayments/vega 2.38.0 → 2.40.0

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/block-update-text-style-strategy.d.ts

@@ -0,0 +1,15 @@
+import { TextStyleAnnotationAction } from '../../actions/text-style-annotation-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Update the text block text style strategy.
+ */
+export declare class BlockUpdateTextStyleStrategy extends ActionHandleStrategy<TextStyleAnnotationAction, RTETextBlock> {
+  /**
+   * Update the text block type and add or remove the bold style from child nodes.
+   *
+   * @param {TextStyleAnnotationAction} action - The text style annotation action.
+   * @param {RTETextBlock} target - The current text block.
+   */
+  protected handleAction(action: TextStyleAnnotationAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/image-set-annotation-map-strategy.d.ts

@@ -0,0 +1,13 @@
+import { ImageAnnotationAction } from '../../actions/image-annotation-action';
+import { SelectionChangeAction } from '../../actions/selection-change-action';
+import { RTEImageNode } from '../../nodes/image-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Update the image node annotation map strategy.
+ */
+export declare class ImageSetAnnotationMapStrategy extends ActionHandleStrategy<ImageAnnotationAction | SelectionChangeAction, RTEImageNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ImageAnnotationAction | SelectionChangeAction, target: RTEImageNode): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/node-split-text-strategy.d.ts

@@ -0,0 +1,47 @@
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { TextSplittableAction } from '../../actions/splittable-action.abstract';
+import { Nullable } from '../../../../../types/general';
+/**
+ * Split the text node into two or there nodes according to the rules.
+ */
+export declare class NodeSplitTextStrategy extends ActionHandleStrategy<TextSplittableAction, RTETextNode, Nullable<RTETextNode>> {
+  private applyTargetNode;
+  /**
+   * Split the text node.
+   *
+   * @param {TextSplittableAction} action - The split action.
+   * @param {RTETextNode} target - The text node that need to be splited.
+   * @returns {Nullable<RTETextNode>} - The new insert text node or the current text node that need to apply the action.
+   */
+  protected handleAction(action: TextSplittableAction, target: RTETextNode): Nullable<RTETextNode>;
+  /**
+   * Insert the new node at the start offset
+   *
+   * @param {number} startOffset - The start position offset
+   * @param {RTETextNode} target - RTETextNode
+   * @returns {RTETextNode[]} - RTETextNode array
+   */
+  private insertNewNode;
+  /**
+   * 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;
+  /**
+   * Split text node with range
+   *
+   * @param {Range} range - Selection range
+   * @param {RTETextNode} target - RTETextNode
+   * @returns {RTETextNode[] | this} RTETextNode array
+   */
+  private splitTextNode;
+  /**
+   * Store the text node which need to apply the annotation. Clear the value if the input is null.
+   *
+   * @param {RTETextNode | null} node - The new text node.
+   */
+  private setApplyTargetNode;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/apply-annotation-strategies/node-update-annotation-map-strategy.d.ts

@@ -0,0 +1,15 @@
+import { AnnotationAction } from '../../actions/annotation-action.abstract';
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The current strategy used to modify the text node annotation map.
+ */
+export declare class NodeUpdateAnnotationMapStrategy extends ActionHandleStrategy<AnnotationAction, RTETextNode> {
+  /**
+   * Remove or set annotation to the text node annotation map.
+   *
+   * @param {AnnotationAction} action - The annotation action instance.
+   * @param {RTETextNode} target - The current text node.
+   */
+  protected handleAction(action: AnnotationAction, target: RTETextNode): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-append-blocks-strategy.d.ts

@@ -0,0 +1,13 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append new block array to list block or VegaRTEContent instance strategy.
+ */
+export declare class BlockAppendBlocksStrategy extends ActionHandleStrategy<AppendChildNodesAction, RTEListBlock | VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: AppendChildNodesAction, target: RTEListBlock | VegaRTEContent): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-append-nodes-strategy.d.ts

@@ -0,0 +1,16 @@
+import { AppendChildNodesAction } from '../../actions/append-child-nodes-action';
+import { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append the nodes to the text block or image block strategy.
+ */
+export declare class BlockAppendNodesStrategy extends ActionHandleStrategy<AppendChildNodesAction, RTETextBlock | RTEImageBlock> {
+  /**
+   * Append the text nodes to the text block or the image block.
+   *
+   * @param {AppendChildNodesAction} action - The remove child action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The parent block of the node that will be removed.
+   */
+  protected handleAction(action: AppendChildNodesAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-image-strategy.d.ts

@@ -0,0 +1,19 @@
+import { DeleteBlockContentAction } from '../../actions/delete-block-content-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import { BlockDeleteNodeContentStrategy } from './block-delete-node-content-strategy';
+/**
+ * The image block delete the image node strategy.
+ */
+export declare class BlockDeleteImageStrategy extends BlockDeleteNodeContentStrategy<RTEImageBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: DeleteBlockContentAction, target: RTEImageBlock): void;
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   * @param {RTEImageBlock} target - The image block.
+   */
+  private deleteNodeContent;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-node-content-strategy.d.ts

@@ -0,0 +1,61 @@
+import { Nullable } from '../../../../../types/general';
+import { DeleteBlockContentAction } from '../../actions/delete-block-content-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { RTENode } from '../../nodes/node.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The delete node content contains some common functions that used for image block delete the image node or text block delete text node.
+ */
+export declare abstract class BlockDeleteNodeContentStrategy<T extends RTETextBlock | RTEImageBlock> extends ActionHandleStrategy<DeleteBlockContentAction, T> {
+  /**
+   * Returns the previous node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the previous block last node
+   */
+  protected getPreviousNode(currentNode: RTENode): Nullable<RTENode>;
+  /**
+   * Returns the next node relative to the current node in a rich text editor structure.
+   *
+   * @param {RTENode} currentNode - An object of type `RTENode`.
+   * @returns {Nullable<RTENode>} the next block first node
+   */
+  protected getNextNode(currentNode: RTENode): Nullable<RTENode>;
+  /**
+   * Determines if a given node is the first node within the current state.
+   *
+   * @param {RTENode} currentNode - An object representing a node in a rich text editor (RTE).
+   * @returns {boolean} True or false;
+   */
+  protected isContentFirstNode(currentNode: RTENode): boolean;
+  /**
+   * TODO: The getPreviousBlock add nest list support
+   * This function retrieves the previous block in a rich text editor, considering different scenarios such as being in a bullet list.
+   *
+   * @param {RTEBlock} currentBlock - Used to retrieve the previous block relative to the given `currentBlock` within a rich text editor context.
+   * @returns {Nullable<RTEBlock>} The previous block if existing
+   */
+  private getPreviousBlock;
+  /**
+   * Returns the last node within a given RTE block, handling different block types accordingly.
+   *
+   * @param {RTEBlock} currentBlock - Returns the last node within that block.
+   * @returns {Nullable<RTENode>} Returns the last node of the given `currentBlock` object.
+   */
+  private getBlockLastNode;
+  /**
+   * Returns the first node within a given RTE block, handling different block types accordingly.
+   *
+   * @param {RTEBlock} currentBlock - Returns the first node within that block.
+   * @returns {Nullable<RTENode>} Returns the first node of the given `currentBlock` object.
+   */
+  private getBlockFirstNode;
+  /**
+   * This function retrieves the next block in a rich text editor, considering different scenarios such as being in a bullet list.
+   *
+   * @param {RTEBlock} currentBlock - Used to retrieve the next block relative to the given `currentBlock` within a rich text editor context.
+   * @returns {Nullable<RTEBlock>} The next block if existing
+   */
+  private getNextBlock;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-text-content-strategy.d.ts

@@ -0,0 +1,19 @@
+import { DeleteBlockContentAction } from '../../actions/delete-block-content-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { BlockDeleteNodeContentStrategy } from './block-delete-node-content-strategy';
+/**
+ * The text block delete text content strategy.
+ */
+export declare class BlockDeleteTextContentStrategy extends BlockDeleteNodeContentStrategy<RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: DeleteBlockContentAction, target: RTETextBlock): void;
+  /**
+   * Handle the delete text logic when press delete key.
+   *
+   * @param {DeleteBlockContentAction} action - ModifyContentAction
+   * @param {RTETextBlock} target - Current text block
+   */
+  protected deleteNodeContent(action: DeleteBlockContentAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-after-strategy.d.ts

@@ -0,0 +1,13 @@
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import type { RTEListBlock } from '../../blocks/list-block';
+import type { VegaRTEContent } from '../../content-state';
+import { BlockInsertBlocksBeforeStrategy } from './block-insert-blocks-before-strategy';
+/**
+ * Insert block array at the behind of the block strategy.
+ */
+export declare class BlockInsertBlocksAfterStrategy extends BlockInsertBlocksBeforeStrategy {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertBlocksAfterAction, target: RTEListBlock | VegaRTEContent): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-blocks-before-strategy.d.ts

@@ -0,0 +1,23 @@
+import { InsertBlocksAfterAction } from '../../actions/insert-blocks-after-block';
+import { InsertBlocksBeforeAction } from '../../actions/insert-blocks-before-block';
+import { RTEBlock } from '../../blocks/block.abstract';
+import type { RTEListBlock } from '../../blocks/list-block';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert block array at the front of the block strategy.
+ */
+export declare class BlockInsertBlocksBeforeStrategy extends ActionHandleStrategy<InsertBlocksBeforeAction | InsertBlocksAfterAction, RTEListBlock | VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertBlocksBeforeAction, target: RTEListBlock | VegaRTEContent): void;
+  /**
+   * Replaces a specific block with an array of blocks within a RTEContentBlock array.
+   *
+   * @param {RTEListBlock|VegaRTEContent} target - The list block or the VegaRTEContent instance.
+   * @param {RTEBlock} referBlock - Used as a reference block to identify the block that needs to be replaced in the `blocks` array.
+   * @param {RTEBlock[]} blocks - An array of RTEBlock objects that you want to replace the `referBlock` with in the `blocks` array.
+   */
+  protected replaceBlockWithBlocks(target: RTEListBlock | VegaRTEContent, referBlock: RTEBlock, blocks: RTEBlock[]): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-image-into-text-strategy.d.ts

@@ -0,0 +1,15 @@
+import { InsertImageToBlockAction } from '../../actions/insert-image-to-block-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a image block into the text block at special position strategy.
+ */
+export declare class BlockInsertImageIntoTextStrategy extends ActionHandleStrategy<InsertImageToBlockAction, RTETextBlock> {
+  /**
+   * insertImage
+   *
+   * @param {InsertImageToBlockAction} action - Insert image action instance.
+   * @param {RTETextBlock} target - The text block.
+   */
+  protected handleAction(action: InsertImageToBlockAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-strategy.d.ts

@@ -0,0 +1,30 @@
+import { LineBreakSingleBlockAction } from '../../actions/line-break-single-block-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a line break node into current text block at special position strategy.
+ */
+export declare class BlockInsertLineBreakStrategy extends ActionHandleStrategy<LineBreakSingleBlockAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: LineBreakSingleBlockAction, target: RTETextBlock): void;
+  /**
+   * lineBreakSingleBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
+  private lineBreakSingleBlock;
+  /**
+   * mergeLineBreakNodes
+   *
+   * @param {RTENode[]} beforeNodes -
+   * @param {RTETextNode} lineBreakNode -
+   * @param {RTENode[]} afterNodes -
+   * @param {RTETextBlock} target -
+   */
+  private mergeLineBreakNodes;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-line-break-with-blocks-strategy.d.ts

@@ -0,0 +1,36 @@
+import { lineBreakMultipleBlocksAction } from '../../actions/line-break-multiple-block-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a line break node into multiple blocks selection at special position strategy.
+ */
+export declare class BlockInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy<lineBreakMultipleBlocksAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: lineBreakMultipleBlocksAction, target: RTETextBlock): void;
+  /**
+   * lineBreakMultipleBlocks
+   *
+   * @param {RTEBlock[]} selectedBlocks -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTETextNode>} Nullable<RTETextNode>
+   */
+  private lineBreakMultipleBlocks;
+  /**
+   * Concat the child nodes of multiple RTEBlocks if both are not images.
+   *
+   * @param {RTEBlock[]} blocks - multiple block of content in a rich text editor, such as a paragraph, heading, image, etc.
+   * @returns {RTENode[]} Array of connected block nodes
+   */
+  private concatBlocksNodes;
+  /**
+   * mergeLineBreakNodes
+   *
+   * @param {RTENode[]} beforeNodes -
+   * @param {RTETextNode} lineBreakNode -
+   * @param {RTENode[]} afterNodes -
+   * @param {RTETextBlock} target -
+   */
+  private mergeLineBreakNodes;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-new-paragraph-strategy.d.ts

@@ -0,0 +1,29 @@
+import { BreakSingleBlockAction } from '../../actions/break-single-block-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert new paragraph into current text block at special position.
+ */
+export declare class BlockInsertNewParagraphStrategy extends ActionHandleStrategy<BreakSingleBlockAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: BreakSingleBlockAction, target: RTETextBlock): void;
+  /**
+   * breakSingleTextBlock
+   *
+   * @param {RTETextNode} splitNode -
+   * @param {number} startOffsetOfNode -
+   * @param {RTETextBlock} target -
+   * @returns {Nullable<RTEBlock>} Nullable<RTEBlock>
+   */
+  private breakSingleTextBlock;
+  /**
+   * copyInlineStyleToNewParagraph
+   *
+   * @param {RTETextNode} needCopedNode - The text node.
+   * @param {RTETextBlock} target - The text block.
+   * @returns {RTETextBlock} - The new paragraph.
+   */
+  private copyInlineStyleToNewParagraph;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-after-node-strategy.d.ts

@@ -0,0 +1,13 @@
+import { InsertNodesAfterAction } from '../../actions/insert-nodes-after-node-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { BlockReplaceNodeWithNodesStrategy } from './block-replace-node-with-nodes-strategy';
+/**
+ * Insert some text nodes at the behind of the node strategy.
+ */
+export declare class BlockInsertNodesAfterNodeStrategy extends BlockReplaceNodeWithNodesStrategy {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertNodesAfterAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-insert-nodes-before-node-strategy.d.ts

@@ -0,0 +1,13 @@
+import { InsertNodesBeforeAction } from '../../actions/insert-nodes-before-node-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { BlockReplaceNodeWithNodesStrategy } from './block-replace-node-with-nodes-strategy';
+/**
+ * Insert some text nodes at the before of the node strategy.
+ */
+export declare class BlockInsertNodesBeforeNodeStrategy extends BlockReplaceNodeWithNodesStrategy {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertNodesBeforeAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy.d.ts

@@ -0,0 +1,16 @@
+import { MergeTwoBlocksNodesAction } from '../../actions/merge-two-blocks-nodes-action';
+import { RTEImageBlock } from '../../blocks/image-block';
+import { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Append the second block child nodes to the first block child nodes and remove the second block strategy.
+ */
+export declare class BlockMergeNodesStrategy extends ActionHandleStrategy<MergeTwoBlocksNodesAction, RTETextBlock | RTEImageBlock> {
+  /**
+   * Merges the child nodes of two RTEBlocks if they have the same type or both are not images.
+   *
+   * @param {MergeTwoBlocksNodesAction} action - The merge block nodes action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The first text block or image block.
+   */
+  protected handleAction(action: MergeTwoBlocksNodesAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-remove-child-block-strategy.d.ts

@@ -0,0 +1,13 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * List block or VegaRTEContent remove child block strategy.
+ */
+export declare class BlockRemoveChildBlockStrategy extends ActionHandleStrategy<RemoveChildAction, RTEListBlock | VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: RemoveChildAction, target: RTEListBlock | VegaRTEContent): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-remove-node-strategy.d.ts

@@ -0,0 +1,17 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove the node from the text block or image block strategy.
+ */
+export declare class BlockRemoveNodeStrategy extends ActionHandleStrategy<RemoveChildAction, RTETextBlock | RTEImageBlock> {
+  /**
+   * Remove the text node from the parent text block or remove the image node from the parent image block.
+   * Remove the block if the block nodes is empty after delete the current node.
+   *
+   * @param {RemoveChildAction} action - The remove child action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The parent block of the node that will be removed.
+   */
+  protected handleAction(action: RemoveChildAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-replace-node-with-nodes-strategy.d.ts

@@ -0,0 +1,20 @@
+import { InsertNodesAfterAction } from '../../actions/insert-nodes-after-node-action';
+import { InsertNodesBeforeAction } from '../../actions/insert-nodes-before-node-action';
+import { RTEBlock } from '../../blocks/block.abstract';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { RTENode } from '../../nodes/node.abstract';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replace the node with new node array strategy.
+ */
+export declare abstract class BlockReplaceNodeWithNodesStrategy extends ActionHandleStrategy<InsertNodesBeforeAction | InsertNodesAfterAction, RTETextBlock | RTEImageBlock> {
+  /**
+   * Replace the current node to the new node array.
+   *
+   * @param {RTEBlock} target - The image block or the text block.
+   * @param {RTENode} referNode - The text node or the image node.
+   * @param {RTENode[]} newNodes - The array of the text node or the image node.
+   */
+  protected replaceNodeWithNodes(target: RTEBlock, referNode: RTENode, newNodes: RTENode[]): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-replace-nodes-strategy.d.ts

@@ -0,0 +1,16 @@
+import { ReplaceChildNodesAction } from '../../actions/replace-child-nodes-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove all nodes and append new nodes strategy.
+ */
+export declare class BlockReplaceNodesStrategy extends ActionHandleStrategy<ReplaceChildNodesAction, RTETextBlock | RTEImageBlock> {
+  /**
+   * Empty the text block or image block nodes and add new nodes.
+   *
+   * @param {ReplaceChildNodesAction} action - The replace child nodes action instance.
+   * @param {RTETextBlock | RTEImageBlock} target - The text block or the image block.
+   */
+  protected handleAction(action: ReplaceChildNodesAction, target: RTETextBlock | RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-split-with-image-node-strategy.d.ts

@@ -0,0 +1,30 @@
+import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Split the current image block with a special position strategy.
+ */
+export declare class BlockSplitWithImageNodeStrategy extends ActionHandleStrategy<SplitBlockWithNodeAction, RTEImageBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SplitBlockWithNodeAction, target: RTEImageBlock): void;
+  /**
+   * The image offset should be 0 or 1
+   * <vega-rich-text-image-editor><img /></vega-rich-text-image-editor>
+   *
+   * @param {RTEImageNode} imageNode The split point image node.
+   * @param {number} imageOffset The cursor point 0 | 1.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {Nullable<RTEBlock>} The new block after split
+   */
+  private splitImageNodes;
+  /**
+   * 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.
+   * @param {RTEImageBlock} target The image block.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   */
+  private cloneWithNodes;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-split-with-text-node-strategy.d.ts

@@ -0,0 +1,24 @@
+import { Nullable } from '../../../../../types/general';
+import { SplitBlockWithNodeAction } from '../../actions/split-block-with-node-action';
+import { RTEBlock } from '../../blocks/block.abstract';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Split the current node with a special position strategy.
+ */
+export declare class BlockSplitWithTextNodeStrategy extends ActionHandleStrategy<SplitBlockWithNodeAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SplitBlockWithNodeAction, target: RTETextBlock): 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`.
+   * @param {RTETextBlock} textBlock - The text block need to be splited.
+   * @returns {Nullable<RTEBlock>} return either an RTEBlock object or null.
+   */
+  protected splitTextNodeBlock(splitNode: RTETextNode, startOffsetOfNode: number, textBlock: RTETextBlock): Nullable<RTEBlock>;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy.d.ts

@@ -0,0 +1,15 @@
+import { TransformListAction } from '../../actions/transform-list-action';
+import type { RTETextBlock } from '../../blocks/text-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected blocks to list strategy.
+ */
+export declare class BlockTransformToListStrategy extends ActionHandleStrategy<TransformListAction, RTETextBlock> {
+  /**
+   * This method will create a empty list block and append all selected blocks as list item block.
+   *
+   * @param {TransformListAction} action - The transform list action instance.
+   * @param {RTETextBlock} target - The first item of the selected block.
+   */
+  protected handleAction(action: TransformListAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-block-insert-image-strategy.d.ts

@@ -0,0 +1,12 @@
+import { InsertImageToBlockAction } from '../../actions/insert-image-to-block-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a image node at the special position of image block.
+ */
+export declare class ImageBlockInsertImageStrategy extends ActionHandleStrategy<InsertImageToBlockAction, RTEImageBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertImageToBlockAction, target: RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-strategy.d.ts

@@ -0,0 +1,15 @@
+import { LineBreakSingleBlockAction } from '../../actions/line-break-single-block-action';
+import { RTEImageBlock } from '../../blocks/image-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The image block insert line break strategy.
+ */
+export declare class ImageInsertLineBreakStrategy extends ActionHandleStrategy<LineBreakSingleBlockAction, RTEImageBlock> {
+  /**
+   * The image block not support insert the line break node, so invoke the insert new paragraph logic directly.
+   *
+   * @param {LineBreakSingleBlockAction} action - The action instance.
+   * @param {RTEImageBlock} target - The image block.
+   */
+  protected handleAction(action: LineBreakSingleBlockAction, target: RTEImageBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/image-insert-line-break-with-blocks-strategy.d.ts

@@ -0,0 +1,27 @@
+import { lineBreakMultipleBlocksAction } from '../../actions/line-break-multiple-block-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a line break node into multiple blocks selection at special position strategy.
+ */
+export declare class ImageInsertLineBreakWithBlocksStrategy extends ActionHandleStrategy<lineBreakMultipleBlocksAction, RTEImageBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: lineBreakMultipleBlocksAction, target: RTEImageBlock): void;
+  /**
+   * 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.
+   * @param {RTEImageBlock} target - The image block.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   */
+  private lineBreakMultipleBlocks;
+  /**
+   * Concat the child nodes of multiple RTEBlocks if both are not images.
+   *
+   * @param {RTEBlock[]} blocks - multiple block of content in a rich text editor, such as a paragraph, heading, image, etc.
+   * @returns {RTENode[]} Array of connected block nodes
+   */
+  private concatBlocksNodes;
+}