@globalpayments/vega 2.102.0 → 2.103.0

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/paste-processing-strategy.abstract.d.ts

@@ -1,5 +1,7 @@
+import type { PasteInput, PasteOutput } from '../type';
 export declare enum RTEPasteMode {
   RICH = "rich",
+  PLAIN = "plain",
   WORD = "word"
 }
 /**
@@ -44,18 +46,38 @@ export declare abstract class AbstractPasteProcessingStrategy {
    * @returns {boolean} `false` unless a strategy opts into image processing.
    */
   get supportsImageProcessing(): boolean;
+  /** @returns {boolean} Whether this strategy consumes `text/plain` instead of `text/html` (default: false). */
+  get consumesPlainText(): boolean;
+  /**
+   * Owns the complete content policy for this paste mode. Subclasses that
+   * only need a different source string should override {@link getSourceContent}
+   * instead of re-implementing this method.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Complete downstream paste contract.
+   */
+  transform(input: PasteInput): PasteOutput;
+  /**
+   * Resolves the source string passed to {@link process}. Defaults to
+   * `input.text` when {@link consumesPlainText} is true, otherwise `input.html`.
+   *
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {string} Content to feed into `process`.
+   */
+  protected getSourceContent(input: PasteInput): string;
   /**
    * Detect whether this strategy should handle the given HTML content.
    *
-   * @param html Raw clipboard HTML
-   * @returns true if this strategy should process the content
+   * @param {string} html Raw clipboard HTML.
+   * @returns {boolean} Whether this strategy should process the content.
    */
   abstract canHandle(html: string): boolean;
   /**
-   * Transform/sanitize the HTML content for this paste source.
+   * Transform clipboard content for the RTE pipeline.
+   * Receives `text/html` by default or `text/plain` if {@link consumesPlainText} is true.
    *
-   * @param html Raw clipboard HTML
-   * @returns Processed HTML ready for the RTE pipeline
+   * @param {string} content Raw clipboard content (HTML or plain text).
+   * @returns {string} Processed HTML.
    */
-  abstract process(html: string): string;
+  abstract process(content: string): string;
 }

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/paste-strategy-selector.d.ts

@@ -1,5 +1,6 @@
 import { AbstractPasteProcessingStrategy } from './paste-processing-strategy.abstract';
 import { RTEPasteMode } from './paste-processing-strategy.abstract';
+import { PasteInput } from '../type';
 /**
  * Centralized selector for paste processing strategies.
  *
@@ -11,6 +12,18 @@ import { RTEPasteMode } from './paste-processing-strategy.abstract';
 export declare class PasteStrategySelector {
   private readonly defaultStrategy;
   private strategies;
+  /**
+   * Selects the strategy that will process this paste.
+   *
+   * When `explicitMode` is provided and not `rich`, the strategy registered for that mode
+   * is used. Otherwise the highest-priority strategy whose `canHandle` matches the HTML
+   * wins, falling back to the default pass-through strategy.
+   *
+   * @param {PasteInput} input Captured clipboard payload used for auto-detection.
+   * @param {RTEPasteMode} [explicitMode] Paste mode the user picked from the chooser.
+   * @returns {AbstractPasteProcessingStrategy} Strategy to run for this paste.
+   */
+  select(input: PasteInput, explicitMode?: RTEPasteMode): AbstractPasteProcessingStrategy;
   /**
    * Select the appropriate strategy for the given HTML content.
    * Returns the highest-priority strategy that can handle the content.

package/dist/types/components/vega-rich-text-editor/extensions/paste/strategies/plain-paste-strategy.d.ts

@@ -0,0 +1,29 @@
+import { AbstractPasteProcessingStrategy, RTEPasteMode } from './paste-processing-strategy.abstract';
+import { PasteInput, PasteOutput } from '../type';
+/** Converts plain-text clipboard to paragraph-per-line HTML. */
+export declare class PlainPasteProcessingStrategy extends AbstractPasteProcessingStrategy {
+  /** @returns {RTEPasteMode} Plain-text paste mode. */
+  get type(): RTEPasteMode;
+  /** @returns {boolean} Always `true`; consumes `text/plain` instead of `text/html`. */
+  get consumesPlainText(): boolean;
+  /** @returns {boolean} Always `false`; never auto-selected. */
+  canHandle(): boolean;
+  /**
+   * Converts plain text to paragraph HTML; every `\n` starts a new paragraph.
+   *
+   * @param {string} text - Clipboard `text/plain` payload.
+   * @param {boolean} decodeEncodedWhitespace - Decode markers emitted by HTML conversion.
+   * @returns {string} Paragraph HTML.
+   */
+  process(text: string, decodeEncodedWhitespace?: boolean): string;
+  /**
+   * @param {PasteInput} input Complete clipboard payload.
+   * @returns {PasteOutput} Plain HTML, canonical text, and whitespace marker contract.
+   */
+  transform(input: PasteInput): PasteOutput;
+  /**
+   * @param {PasteInput} input Clipboard content used to derive canonical plain text.
+   * @returns {PlainTextSource} Canonical text and whether it contains whitespace sentinels.
+   */
+  private getPlainTextSource;
+}

package/dist/types/components/vega-rich-text-editor/extensions/paste/type.d.ts

@@ -0,0 +1,35 @@
+import { RTEExtensionContext } from '../../interface';
+import type { RTEPasteMode } from './strategies/paste-processing-strategy.abstract';
+export declare type SelectedNodes = ReturnType<RTEExtensionContext['getSelectedNodes']>;
+export declare type PendingPastePayload = {
+  html: string;
+  text: string;
+  range: Range | null;
+  selectedNodes: SelectedNodes;
+  files: File[];
+  rtf: string;
+};
+export declare type ClipboardFileContent = {
+  files: File[];
+  rtf: string;
+};
+export declare type PasteInput = {
+  html: string;
+  text: string;
+  files: File[];
+  rtf: string;
+};
+export declare type PasteOutput = {
+  html: string;
+  text: string;
+  mode: RTEPasteMode;
+  markers: Record<string, string>;
+  extractImages: boolean;
+  imagesToExtract: File[];
+};
+export declare type VegaRTEPasteImage = {
+  /** Unique identifier used to fill in the uploaded URL later. */
+  id: string;
+  /** Pasted image file to upload. */
+  file: File;
+};

package/dist/types/components/vega-rich-text-editor/helpers/utils.d.ts

@@ -39,3 +39,50 @@ export declare function escapeHtml(text: string): string;
  * @returns {string} Escaped attribute-safe value.
  */
 export declare function escapeHtmlAttribute(value: string): string;
+/**
+ * Normalizes clipboard line endings and splits into lines. Low-level primitive behind
+ * `toPlainPasteLines`, which layers boundary-whitespace handling on top and is the single
+ * conversion source used by plain-mode paste.
+ *
+ * @param {string} text Raw clipboard plain text.
+ * @returns {string[]} Lines with `\r\n`/`\r` normalized to `\n` and split on `\n`.
+ */
+export declare function normalizePlainTextLines(text: string): string[];
+/**
+ * Sentinels for whitespace that must survive plain-mode boundary collapsing (e.g. code-block
+ * indentation derived from HTML). `htmlToPlainText` can emit these in place of real spaces/tabs so
+ * that `toPlainPasteLines` leaves them untouched — they are not matched by `\s` — and decodes them
+ * back to real characters after collapsing the paste's insignificant leading/trailing whitespace.
+ */
+export declare const PRESERVED_SPACE: string;
+export declare const PRESERVED_TAB: string;
+/**
+ * Single source of truth for plain-mode paste conversion: turns raw clipboard text into
+ * the canonical list of lines used by both representations of the pasted content — the
+ * `text/html` payload emitted by `PlainPasteProcessingStrategy` and the RTE text/newline
+ * nodes built by `InsertPasteHandler`. Both must derive from this helper so whitespace and
+ * boundary handling cannot drift apart.
+ *
+ * Per-paragraph handling: lines carrying {@link PRESERVED_SPACE}/{@link PRESERVED_TAB}
+ * sentinels come from code-block sources (via the preservation branch of
+ * `extractBlockAwareText`) and are kept verbatim so significant indentation survives;
+ * all other lines get a normal `String.prototype.trim()` (including NBSP) so
+ * paragraph-boundary whitespace from non-code sources is treated as noise.
+ * When `decodeEncodedWhitespace` is enabled, sentinels are decoded back to real
+ * space/tab characters after the per-line pass.
+ *
+ * @param {string} text Raw clipboard plain text.
+ * @param {boolean} decodeEncodedWhitespace Whether HTML-derived sentinels should be decoded.
+ * @returns {string[]} Canonical plain-mode lines.
+ */
+export declare function toPlainPasteLines(text: string, decodeEncodedWhitespace?: boolean): string[];
+/**
+ * Serializes canonical plain-mode lines into paragraph-per-line HTML.
+ *
+ * Built as a string rather than via DOM `outerHTML` serialization, which collapses
+ * consecutive spaces in non-`<pre>` text nodes and would lose intentional whitespace.
+ *
+ * @param {string[]} lines Canonical plain-mode lines from {@link toPlainPasteLines}.
+ * @returns {string} Paragraph HTML where each line is an individual paragraph.
+ */
+export declare function plainPasteLinesToHtml(lines: string[]): string;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/abstract-delete-content-handler.d.ts

@@ -1,3 +1,4 @@
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { RTEBlock } from '../../../../dto/blocks/block.abstract';
 import { RTENode } from '../../../../dto/nodes/node.abstract';
 import { Nullable } from '../../../../../../types/general';
@@ -15,8 +16,20 @@ export interface ForwardDeletePosition {
 export declare abstract class AbstractDeleteContentHandler extends BaseHandler {
   /**
    * Delete the selected node(s) from the current state.
+   *
+   * @returns {CompositionStep[]} The content + caret steps applied atomically as one flushable composition.
+   */
+  handleEvent(): CompositionStep[];
+  /**
+   * Builds the ordered steps for a single-block deletion: the delete runs first, then a caret step
+   * reads the delete action's post-apply `previousNode`/`nextNode` to decide where the caret lands.
+   *
+   * @param {RTENode} resolvedNode - The node the deletion is anchored on.
+   * @param {number} resolvedOffset - The caret offset within `resolvedNode` at deletion time.
+   * @param {Nullable<RTENode>} caretAnchor - A node the caret must stay on regardless of the delete result.
+   * @returns {CompositionStep[]} The delete step followed by the dependent caret step.
    */
-  handleEvent(): void;
+  protected buildDeleteSteps(resolvedNode: RTENode, resolvedOffset: number, caretAnchor: Nullable<RTENode>): CompositionStep[];
   /**
    * Computes the caret position one step to the right, used to translate a forward delete into a backspace.
    *
@@ -49,12 +62,10 @@ export declare abstract class AbstractDeleteContentHandler extends BaseHandler {
    * @param {RTEBlock} block - The first block instance
    */
   protected convertFirstBlockToParagraph(block: RTEBlock): void;
-  /**
-   * Creates a new paragraph element with a text node and appends it to the current state.
-   */
-  protected insertDefaultParagraph(): void;
   /**
    * Handles a single-block deletion of content within an RTE editor for the handler's direction.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the deletion, empty when nothing is deleted.
    */
-  protected abstract deleteContentWithSingleBlock(): void;
+  protected abstract deleteContentWithSingleBlock(): CompositionStep[];
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/backward-delete-content-handler.d.ts

@@ -1,8 +1,12 @@
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { AbstractDeleteContentHandler } from './abstract-delete-content-handler';
 /** Handles a backspace (leftward) deletion of content within a VegaRTE editor. User press backspace will trigger this method */
 export declare class BackwardDeleteContentHandler extends AbstractDeleteContentHandler {
   /**
    * Handles a backspace (leftward) deletion of content within a single block in an RTE editor.
+   *
+   * @returns {Nullable<CompositionStep[]>} The delete + caret steps, empty when the deletion is delegated or a no-op.
    */
-  protected deleteContentWithSingleBlock(): void;
+  protected deleteContentWithSingleBlock(): Nullable<CompositionStep[]>;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/base-handler.d.ts

@@ -1,5 +1,7 @@
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { RTETextBlock } from '../../../../dto/blocks/text-block';
 import { VegaRTEContent } from '../../../../dto/content-state';
+import { RTEFlushChangesPayload } from '../../../../dto/flush-changes-payload';
 import { RTENode } from '../../../../dto/nodes/node.abstract';
 import { SelectionController } from '../../selection-controller';
 /** This code snippet is defining an abstract class named `BaseHandler` with an abstract method `execute`. */
@@ -7,15 +9,35 @@ export declare abstract class BaseHandler<TEvent extends Event = InputEvent> {
   protected currentState: VegaRTEContent;
   protected selectionController: SelectionController;
   protected richTextEditorRef: HTMLVegaRichTextEditorElement;
+  /**
+   * Default flush payload emitted after `handleEvent` completes. This is the single source of
+   * truth for the defaults — the observer does not re-apply any fallback values. Subclasses may override
+   * this field to opt out of flushing (assign `undefined`) or to change the defaults. Each instance
+   * owns its own copy so mutations from within `handleEvent` (e.g. `InsertTextHandler` updating
+   * `updateSource`) never leak across handler instances.
+   */
+  protected flushOptions: RTEFlushChangesPayload | undefined;
   /**
    * The function `execute` initializes the current state and selection, and then handles an event if provided.
    *
+   * Contract: `handleEvent` MUST be synchronous. A handler that mutates the value returns the
+   * `CompositionStep[]` it applied through `applyComposition`; the flush is then routed through the
+   * shared action pipeline. Handlers that do not mutate the value return nothing
+   *
    * @param {VegaRTEContent} currentState - The current state of the VegaRTE content.
    * @param {SelectionController} selectionController - Manages the selection of items in the user interface.
    * @param {HTMLElement} richTextEditor - The current rich text editor component
    * @param {Event} [event] - It is used to pass an input event to the method for handling.
    */
   execute(currentState: VegaRTEContent, selectionController: SelectionController, richTextEditor: HTMLVegaRichTextEditorElement, event?: TEvent): void;
+  /**
+   * Applies the collected leaf actions as a single flushable `SequentialCompositionAction`, so the value
+   * update and its flush run through the same action pipeline used by every other flushable operation.
+   * Handlers call this before enqueuing selection so caret math reads post-apply node state.
+   *
+   * @param {CompositionStep[]} steps - The ordered leaf actions to apply against their own targets.
+   */
+  protected applyComposition(steps: CompositionStep[] | void): void;
   /**
    * The function `isRootContainer` checks if an HTML element is a root container with a class of 'rich-text-content'.
    *
@@ -57,5 +79,12 @@ export declare abstract class BaseHandler<TEvent extends Event = InputEvent> {
    * @param {HTMLElement} richTextEditor - The current rich text editor component
    */
   private setCurrentRichTextEditor;
-  abstract handleEvent(event?: TEvent): void;
+  /**
+   * Handles an input event in the rich text editor.
+   * If an array or non-empty steps are returned, it means the content has been modified and subsequent processing steps are required to update the component value;
+   * otherwise, the content has not been modified and no further action is needed.
+   *
+   * @param {Event} event - The input event triggered in the rich text editor.
+   */
+  abstract handleEvent(event?: TEvent): CompositionStep[] | void;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/forward-delete-content-handler.d.ts

@@ -1,8 +1,12 @@
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 import { AbstractDeleteContentHandler } from './abstract-delete-content-handler';
 /** Handles a delete (rightward) deletion of content within a VegaRTE editor. User press delete will trigger this method */
 export declare class ForwardDeleteContentHandler extends AbstractDeleteContentHandler {
   /**
    * Handles a delete (rightward) deletion of content within a single block in an RTE editor.
+   *
+   * @returns {Nullable<CompositionStep[]>} The delete + caret steps, empty when the deletion is delegated or a no-op.
    */
-  protected deleteContentWithSingleBlock(): void;
+  protected deleteContentWithSingleBlock(): Nullable<CompositionStep[]>;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-line-break-handler.d.ts

@@ -1,16 +1,22 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
+import { Nullable } from '../../../../../../types/general';
 /** User press shift + enter will tigger this callback */
 export declare class InsertLineBreakHandler extends BaseHandler {
   /**
    * Create new line break node and add node to state value
+   *
+   * @returns {Nullable<CompositionStep[]>} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(): void;
+  handleEvent(): Nullable<CompositionStep[]>;
   /**
    * Insert the \n in text element when root container is empty, should create text block and text node
    * <p>
    *  <span></span>
    *  <span></span>
    * </p>
+   *
+   * @returns {Nullable<CompositionStep[]>} The content + caret steps for the empty root break.
    */
   private breakNewBlock;
   /**
@@ -24,18 +30,29 @@ export declare class InsertLineBreakHandler extends BaseHandler {
    *  <br>
    *  <span>xt</span>
    * </p>
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the single-block break.
    */
   private breakSingleBlock;
   /**
    * Handles breaking blocks in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the multi-block break.
    */
   private breakMultipleBlocks;
   /**
-   * Moves the caret to the next node element in a rich text editor.
+   * Builds the caret step that reads the applied single-block line break to place the caret after it.
+   *
+   * @returns {CompositionStep} The dependent caret step.
+   */
+  private caretToSingleBlockNextNode;
+  /**
+   * Builds the caret operation that moves onto the node following the inserted line break.
    *
-   * @param {RTENode} lineBreakNode - Represents a node element in a rich text editor.
+   * @param {RTENode} lineBreakNode - The inserted line break node.
+   * @returns {CompositionOperation} The caret operation.
    */
-  private switchCaretPositionToSpecifiedNode;
+  private caretOperationToNextNode;
   /**
    * Returns the next sibling node of a given block element in a rich text editor.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paragraph-handler.d.ts

@@ -1,22 +1,30 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /** Insert a paragraph in a rich text editor based on the current selection and event. User type enter will trigger this callback */
 export declare class InsertParagraphHandler extends BaseHandler {
   /**
    * Create new paragraph node and add node to state value
+   *
+   * @returns {CompositionStep[] | void} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(): void;
+  handleEvent(): CompositionStep[] | void;
   /**
    * Handles breaking blocks in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the multi-block break.
    */
   private breakMultipleBlocks;
   /**
    * Handles breaking a single block in an RTE editor based on the current selection and position.
+   *
+   * @returns {CompositionStep[]} The content + caret steps for the single-block break.
    */
   private breakSingleBlock;
   /**
-   * Moves the caret to the next block element in a rich text editor.
+   * Builds the caret operation that moves onto the first child of the newly created block.
    *
-   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   * @param {Nullable<RTEBlock>} newBlock - The block created by the break, or null when none was created.
+   * @returns {CompositionOperation | void} The caret operation, or nothing when there is no target block.
    */
-  private switchCaretPositionToNextElement;
+  private caretToNextElement;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paste-handler.d.ts

@@ -1,4 +1,5 @@
 import { BaseHandler } from './base-handler';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /**
  * Handle user paste
  */
@@ -7,14 +8,15 @@ export declare class InsertPasteHandler extends BaseHandler {
    * Update the state value when user paste html elements.
    *
    * @param {InputEvent} event - Paste event.
+   * @returns {CompositionStep[]} The content + caret steps applied atomically as one flushable composition.
    */
-  handleEvent(event: InputEvent): void;
+  handleEvent(event: InputEvent): CompositionStep[];
   /**
    * Inserts plain-text paste content into the current text node at caret position.
    *
    * @param {RTEPastePayload} payload - Clipboard payload.
    * @param {RTERange} currentRange - Current selection range.
-   * @returns {boolean} True when inline insertion is handled.
+   * @returns {CompositionStep[] | undefined} The content + caret steps when inline insertion applies, otherwise undefined.
    */
   private insertPlainTextInline;
   /**
@@ -38,6 +40,7 @@ export declare class InsertPasteHandler extends BaseHandler {
    * Insert the blocks to root
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @returns {CompositionStep[]} The append step for the root.
    */
   private insertBlocksToRoot;
   /**
@@ -45,6 +48,7 @@ export declare class InsertPasteHandler extends BaseHandler {
    *
    * @param { RTEContentBlock[]} blocks - blocks
    * @param { RTERange } rteRange - rteRange
+   * @returns {CompositionStep[]} The content + caret steps for the content branch.
    */
   private insertBlocksToContent;
   /**
@@ -52,19 +56,24 @@ export declare class InsertPasteHandler extends BaseHandler {
    *
    * @param { RTEContentBlock[]} blocks - blocks
    * @param { RTERange } rteRange - rteRange
+   * @returns {CompositionStep[]} The content + caret steps for the empty-paragraph branch.
    */
   private insertBlocksBeforeEmptyBlock;
   /**
    * Format and parse elements from user paste with simple style preservation.
    *
    * @param {InputEvent} event - Paste event.
+   * @param {RTERange} [currentRange] - Optional range used to resolve the paste location.
    * @returns {RTEContentBlock[]} - RTEContentBlock.
    */
   private parsePastedElements;
   /**
-   * Extracts readable plain text from clipboard HTML.
+   * Extracts plain text from HTML when clipboard lacks `text/plain`.
    *
    * @param {string} html - Clipboard text/html payload.
+   * @param {boolean} keepPreservedWhitespaceMarkers - Keep code-block indentation as sentinels so
+   * the plain-mode boundary collapse in `toPlainPasteLines` does not strip it (that helper decodes
+   * the sentinels). Must stay `false` for the rich path, which feeds `parsePlainText` directly.
    * @returns {string} - Plain text extracted from HTML.
    */
   private extractPlainTextFromHtml;
@@ -76,12 +85,36 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private buildPlainTextFallbackBlocks;
   /**
-   * Moves the caret to a block element in a rich text editor after paste.
+   * Builds plain-text paragraphs by splitting on `\n`.
+   *
+   * Shares `toPlainPasteLines` with `PlainPasteProcessingStrategy` so both
+   * representations of plain-mode content (HTML and RTE nodes) agree on line
+   * boundaries and boundary whitespace.
+   *
+   * @param {string} text - Plain text clipboard content.
+   * @param {RTETextNode} [styleSource] - Optional style to preserve in all nodes.
+   * @param {boolean} decodeEncodedWhitespace - Decode HTML-derived whitespace markers.
+   * @returns {RTEContentBlock[]} Paragraph-per-line blocks.
+   */
+  private buildPlainTextParagraph;
+  /**
+   * Creates a text node for plain paste; optionally inherits style from source node.
+   *
+   * @param {RTETextBlock} paragraph - Parent paragraph.
+   * @param {number} index - Character index for node ID generation.
+   * @param {string} text - Text content.
+   * @param {RTETextNode} [styleSource] - Optional style to inherit.
+   * @returns {RTETextNode} Created text node.
+   */
+  private createPlainTextNode;
+  /**
+   * Builds the caret operation that moves onto a block element in a rich text editor after paste.
    *
    * @param {RTEBlock} newBlock - Block element to move the caret to.
    * @param {boolean} atEnd - When true, places the caret after the last character of the block's last node; otherwise at offset 0 of the first node.
+   * @returns {CompositionOperation | void} The caret operation, or nothing when the block has no children.
    */
-  private switchCaretPositionToNextElement;
+  private caretToBlockOperation;
   /**
    * Parses the content of a plain text and formats it into HTML.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-text-handler.d.ts

@@ -1,17 +1,21 @@
 import { BaseHandler } from './base-handler';
+import { Nullable } from '../../../../../../types/general';
+import { CompositionStep } from '../../../../dto/actions/sequential-composition-action';
 /** Handles inserting text into a VegaRTEContent based on the current selection and input event. User input character will trigger this callback */
 export declare class InsertTextHandler extends BaseHandler {
   /**
    * Update the state value when user type character
    *
    * @param {InputEvent} event - The input event object
+   * @returns {Nullable<CompositionStep[]>} The content actions the base handler applies as one flushable unit.
    */
-  handleEvent(event: InputEvent): void;
+  handleEvent(event: InputEvent): Nullable<CompositionStep[]>;
   /**
    * Insert the text in root element when root container is empty, should create text block and text node
    *
    * @param {string} text The insert text
-   * @returns {RTETextNode} The new create text node
+   * @param {CompositionStep[]} steps The composition steps collector to append the update action to
+   * @returns {Nullable<RTETextNode>} The new create text node
    */
   private insertTextToRoot;
   /**
@@ -19,6 +23,7 @@ export declare class InsertTextHandler extends BaseHandler {
    *
    * @param {RTETextNode} lineBreakNode The current line break node, the text value is \n
    * @param {string} text The text need to insert
+   * @param {CompositionStep[]} steps The composition steps collector to append the resulting action to
    * @returns {Nullable<RTETextNode>} The new text node or the current line break node
    */
   private insertTextToLineBreakNode;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/user-input-controller.d.ts

@@ -32,6 +32,8 @@ export declare class UserInputController extends VegaSlimmer {
   private handleKeyboardAction;
   /**
    * When a user performs an input action within the editable element, this function is triggered.
+   * Each handler owns its own `flushOptions` on `BaseHandler`, so the value update flows through
+   * the shared flush-changes action pipeline without this method having to construct or forward it.
    *
    * @param {InputEvent} e the before input event object
    */

package/dist/types/components/vega-rich-text-editor/utils/html-to-plain-text-utils.d.ts

@@ -0,0 +1,31 @@
+declare type HtmlToPlainTextOptions = {
+  preserveBoundaryBlankLines?: boolean;
+  /**
+   * Keep significant whitespace encoded as {@link PRESERVED_SPACE}/{@link PRESERVED_TAB} sentinels
+   * instead of decoding it to real spaces/tabs. Plain-mode paste sets this so the downstream
+   * `toPlainPasteLines` boundary collapse does not strip code-block indentation; it decodes the
+   * sentinels itself afterwards.
+   */
+  keepPreservedWhitespaceMarkers?: boolean;
+};
+/**
+ * Converts HTML to plain text, preserving line breaks introduced by block-level elements and `<br>`.
+ * Used as a fallback when clipboard data lacks a `text/plain` payload, so structural breaks
+ * (e.g. `<h1>Heading</h1><p>Body</p>`) survive as `Heading\nBody` instead of being flattened.
+ *
+ * @param {string} html HTML content to convert.
+ * @param {HtmlToPlainTextOptions} options Plain-text conversion options.
+ * @returns {string} Block-aware plain text with normalized `\n` line endings.
+ */
+export declare function htmlToPlainText(html: string, options?: HtmlToPlainTextOptions): string;
+/**
+ * Detects whether the clipboard HTML contains a table anywhere. Plain paste uses this together
+ * with a tab check on `text/plain`: a tab-separated `text/plain` only reflects a table's row/
+ * column layout when the clipboard actually has a table, so that combination is pasted from
+ * `text/plain` verbatim (its line breaks are trusted as-is), regardless of any surrounding content.
+ *
+ * @param {string} html HTML content to inspect.
+ * @returns {boolean} Whether the HTML contains a table.
+ */
+export declare function htmlContainsTable(html: string): boolean;
+export {};

package/dist/types/components.d.ts

@@ -2521,6 +2521,12 @@ export namespace Components {
           * @vegaVersion 1.0.5
          */
         "prefixIcon": string;
+        /**
+          * Text displayed before (to the left of) the input value inside the input field.
+          * @default undefined
+          * @vegaVersion 2.103.0
+         */
+        "prefixText": string;
         /**
           * Sets the input field as read-only, preventing direct keyboard input.  When set to `true`, prevents manual keyboard text entry in the input field on    all platforms. On touch devices, this typically suppresses the virtual keyboard.
           * @default false
@@ -2552,6 +2558,12 @@ export namespace Components {
           * @vegaVersion 1.3.0
          */
         "size": 'default' | 'small';
+        /**
+          * Text displayed after (to the right of) the input value inside the input field.
+          * @default undefined
+          * @vegaVersion 2.103.0
+         */
+        "suffixText": string;
         /**
           * Provides the data source for the input's autocomplete suggestion dropdown.  Pass an array of `VegaDropdownSourceItem` objects to enable the suggestions feature. The dropdown appears as the user types, filtering items that match the current input value. When the user selects a suggestion, the `vegaSuggestionItemClick` event is emitted.  **Important:** You must set this property to at least an empty array (`[]`) to enable the suggestion dropdown. If left `undefined`, the feature is disabled.
           * @vegaVersion 2.75.0
@@ -9650,6 +9662,12 @@ declare namespace LocalJSX {
           * @vegaVersion 1.0.5
          */
         "prefixIcon"?: string;
+        /**
+          * Text displayed before (to the left of) the input value inside the input field.
+          * @default undefined
+          * @vegaVersion 2.103.0
+         */
+        "prefixText"?: string;
         /**
           * Sets the input field as read-only, preventing direct keyboard input.  When set to `true`, prevents manual keyboard text entry in the input field on    all platforms. On touch devices, this typically suppresses the virtual keyboard.
           * @default false
@@ -9674,6 +9692,12 @@ declare namespace LocalJSX {
           * @vegaVersion 1.3.0
          */
         "size"?: 'default' | 'small';
+        /**
+          * Text displayed after (to the right of) the input value inside the input field.
+          * @default undefined
+          * @vegaVersion 2.103.0
+         */
+        "suffixText"?: string;
         /**
           * Provides the data source for the input's autocomplete suggestion dropdown.  Pass an array of `VegaDropdownSourceItem` objects to enable the suggestions feature. The dropdown appears as the user types, filtering items that match the current input value. When the user selects a suggestion, the `vegaSuggestionItemClick` event is emitted.  **Important:** You must set this property to at least an empty array (`[]`) to enable the suggestion dropdown. If left `undefined`, the feature is disabled.
           * @vegaVersion 2.75.0