@globalpayments/vega 2.38.0 → 2.39.0

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;
+}

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

@@ -0,0 +1,21 @@
+import { BreakSingleBlockAction } from '../../actions/break-single-block-action';
+import type { RTEImageBlock } from '../../blocks/image-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert a new paragraph at the image block special position strategy.
+ */
+export declare class ImageInsertNewParagraphStrategy extends ActionHandleStrategy<BreakSingleBlockAction, RTEImageBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: BreakSingleBlockAction, target: RTEImageBlock): void;
+  /**
+   * 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.
+   * @param {RTEImageBlock} target - The image block.
+   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
+   */
+  private breakSingleBlock;
+}

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

@@ -0,0 +1,12 @@
+import { ImageUpdateUrlAction } from '../../actions/image-update-url-action';
+import { RTEImageNode } from '../../nodes/image-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * The image node update property url strategy.
+ */
+export declare class ImageUpdateUrlStrategy extends ActionHandleStrategy<ImageUpdateUrlAction, RTEImageNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ImageUpdateUrlAction, target: RTEImageNode): void;
+}

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

@@ -0,0 +1,15 @@
+import { InsertImageToBlockAction } from '../../actions/insert-image-to-block-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert image to list block strategy.
+ */
+export declare class ListInsertImageStrategy extends ActionHandleStrategy<InsertImageToBlockAction, RTEListBlock> {
+  /**
+   * Insert image block at behind of the list item block.
+   *
+   * @param {InsertImageToBlockAction} action - The insert image action instance.
+   * @param {RTEListBlock} target - The list block.
+   */
+  protected handleAction(action: InsertImageToBlockAction, target: RTEListBlock): void;
+}

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

@@ -0,0 +1,15 @@
+import { DeleteBlockContentAction } from '../../actions/delete-block-content-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { BlockDeleteTextContentStrategy } from './block-delete-text-content-strategy';
+/**
+ * The list item block block delete text content strategy.
+ */
+export declare class ListItemDeleteTextContentStrategy extends BlockDeleteTextContentStrategy {
+  /**
+   * Delete the list item content and delete the parent list after delete the last item.
+   *
+   * @param {DeleteBlockContentAction} action - The delete block content action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  protected handleAction(action: DeleteBlockContentAction, target: RTEListItemBlock): void;
+}

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

@@ -0,0 +1,15 @@
+import { InsertImageToBlockAction } from '../../actions/insert-image-to-block-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert image node to list item block strategy.
+ */
+export declare class ListItemInsertImageStrategy extends ActionHandleStrategy<InsertImageToBlockAction, RTEListItemBlock> {
+  /**
+   * The image node can not insert into list item block, so insert image after parent list block.
+   *
+   * @param {InsertImageToBlockAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  protected handleAction(action: InsertImageToBlockAction, target: RTEListItemBlock): void;
+}

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

@@ -0,0 +1,38 @@
+import { BreakSingleBlockAction } from '../../actions/break-single-block-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Insert new paragraph into current list item block at special position.
+ */
+export declare class ListItemInsertNewParagraphStrategy extends ActionHandleStrategy<BreakSingleBlockAction, RTEListItemBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: BreakSingleBlockAction, target: RTEListItemBlock): void;
+  /**
+   * 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.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @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.
+   */
+  private breakSingleListItemBlock;
+  /**
+   * 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.
+   * @param {RTEListItemBlock} target - The list item block.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
+   */
+  private breakListItemAtEnd;
+  /**
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
+   */
+  private copyInlineStyleToNewNode;
+}

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

@@ -0,0 +1,15 @@
+import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove list item nest list block strategy.
+ */
+export declare class ListItemRemoveNestListStrategy extends ActionHandleStrategy<RemoveNestListAction, RTEListItemBlock> {
+  /**
+   * Remove the nest list block from the list item, clear the property children when the children is empty.
+   *
+   * @param {RemoveNestListAction} action - The action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  protected handleAction(action: RemoveNestListAction, target: RTEListItemBlock): void;
+}

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

@@ -0,0 +1,15 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Remove list item child node strategy.
+ */
+export declare class ListItemRemoveNodeStrategy extends ActionHandleStrategy<RemoveChildAction, RTEListItemBlock> {
+  /**
+   * Remove child node from the list item, remove the list item if the list item is empty.
+   *
+   * @param {RemoveChildAction} action - The remove child action instance.
+   * @param {RTEListItemBlock} target - The list item block.
+   */
+  protected handleAction(action: RemoveChildAction, target: RTEListItemBlock): void;
+}

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

@@ -0,0 +1,12 @@
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import type { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replace list item nest list strategy.
+ */
+export declare class ListItemReplaceNestListStrategy extends ActionHandleStrategy<ReplaceNestListAction, RTEListItemBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ReplaceNestListAction, target: RTEListItemBlock): void;
+}

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

@@ -0,0 +1,15 @@
+import { RemoveChildAction } from '../../actions/remove-child-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import { BlockRemoveChildBlockStrategy } from './block-remove-child-block-strategy';
+/**
+ * List remove list item strategy.
+ */
+export declare class ListRemoveListItemStrategy extends BlockRemoveChildBlockStrategy {
+  /**
+   * Remove the list item, check the list item and remove self if the list item is empty.
+   *
+   * @param {RemoveChildAction} action - The remove action instance.
+   * @param {RTEListBlock} target - The list block.
+   */
+  protected handleAction(action: RemoveChildAction, target: RTEListBlock): void;
+}

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

@@ -0,0 +1,12 @@
+import { TransformListAction } from '../../actions/transform-list-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected blocks to list strategy.
+ */
+export declare class ListTransformToListStrategy extends ActionHandleStrategy<TransformListAction, RTEListBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: TransformListAction, target: RTEListBlock): void;
+}

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

@@ -0,0 +1,19 @@
+import { TransformParagraphAction } from '../../actions/transform-paragraph-action';
+import type { RTEListBlock } from '../../blocks/list-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Convert the selected list block to paragraph strategy.
+ */
+export declare class ListTransformToParagraphStrategy extends ActionHandleStrategy<TransformParagraphAction, RTEListBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: TransformParagraphAction, target: RTEListBlock): void;
+  /**
+   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
+   *
+   * @param {RTEListItemBlock} block - The block that will be covered
+   * @returns {RTETextBlock} Returns a `RTETextBlock`.
+   */
+  private toParagraph;
+}

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

@@ -0,0 +1,20 @@
+import { ReplaceSelectedTextAction } from '../../actions/replace-selected-text-action';
+import { RTETextNode } from '../../nodes/text-node';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Replaces the rich text node selected text strategy.
+ */
+export declare class NodeReplaceSelectedTextStrategy extends ActionHandleStrategy<ReplaceSelectedTextAction, RTETextNode> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ReplaceSelectedTextAction, target: RTETextNode): void;
+  /**
+   * 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).
+   * @param {RTETextNode} target - The RTE text node instance.
+   */
+  private replaceSelectedText;
+}