@globalpayments/vega 2.33.0 → 2.34.0

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

@@ -0,0 +1,37 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform text element to DTO.
+ */
+export declare class TextToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Append text node to it block element.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {Nullable<HTMLElement>} - blockElement.
+   */
+  getNextBlockElement(blockElement: Nullable<HTMLElement>): Nullable<HTMLElement>;
+}

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

@@ -0,0 +1,78 @@
+import { RTETextBlock } from '../../../../dto/blocks/text-block';
+import { VegaRTEContent } from '../../../../dto/content-state';
+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`. */
+export declare abstract class BaseHandler {
+  protected currentState: VegaRTEContent;
+  protected selectionController: SelectionController;
+  /**
+   * The function `execute` initializes the current state and selection, and then handles an event if provided.
+   *
+   * @param {VegaRTEContent} currentState - The current state of the VegaRTE content.
+   * @param {SelectionController} selectionController - Manages the selection of items in the user interface.
+   * @param {InputEvent} [event] - It is used to pass an input event to the method for handling.
+   */
+  execute(currentState: VegaRTEContent, selectionController: SelectionController, event?: InputEvent): void;
+  /**
+   * Replaces the selected nodes with the provided text.
+   *
+   * @param {string} text - The insert text
+   * @returns {RTENode} - The selected start node
+   */
+  protected replaceSelectedNodesWithText(text: string): RTENode;
+  /**
+   * The function `isRootContainer` checks if an HTML element is a root container with a class of 'rich-text-content'.
+   *
+   * @param {HTMLElement} element - HTMLElement
+   * @returns {boolean} The boolean value
+   */
+  protected isRootContainer(element: HTMLElement): boolean;
+  /**
+   * Checks if a given HTML element represents an empty paragraph containing only a line break element.
+   *
+   * @param {HTMLElement} node - An HTMLElement node that represents a paragraph element in the HTML document.
+   * @returns {boolean} boolean result
+   */
+  protected isEmptyParagraph(node: HTMLElement): boolean;
+  /**
+   * Removes the selected text at the start and end of a range in a Rich Text Editor.
+   */
+  protected removeRangeStartAndEndSelectedText(): void;
+  /**
+   * Merges text nodes in a rich text editor.
+   *
+   * @param {Node} startContainer - Start text node element
+   * @param {Node} endContainer - End text node element
+   */
+  protected mergeRangeStartAndEnd(startContainer: Node, endContainer: Node): void;
+  /**
+   * Removes selected nodes within a range in a rich text editor content.
+   * The method is only used for different nodes are selected
+   *
+   * @returns {RTENode} The range start node, usually the start node is the first item of selectedNodes, if the selectedNodes is all removed, the start node will be a new text node.
+   */
+  protected removeSelectionRange(): RTENode;
+  /**
+   * Creates a new paragraph with an empty text node and returns it.
+   *
+   * @returns {RTETextBlock} An empty paragraph with a unique identifier and a text node appended to it.
+   */
+  protected createEmptyParagraph(): RTETextBlock;
+  /**
+   * Compares the annotations of two RTETextNodes to determine if they can be merged.
+   *
+   * @param {RTETextNode} nodeA - node A
+   * @param {RTETextNode} nodeB - node B
+   * @returns {boolean} true or false
+   */
+  private shouldMergeTextNode;
+  /**
+   * The function initializes the current state and selection controller in TypeScript.
+   *
+   * @param {VegaRTEContent} currentState - The current state of a Vega runtime environment content.
+   * @param {SelectionController} selectionController - It is used to manage the selection of content within the VegaRTE editor.
+   */
+  private initCurrentStateAndSelection;
+  abstract handleEvent(event?: InputEvent): void;
+}

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

@@ -0,0 +1,33 @@
+import { BaseHandler } from './base-handler';
+/** Handles the deletion of content within a VegaRTE editor. User press backspace or delete will trigger this method */
+export declare class DeleteContentHandler extends BaseHandler {
+  /**
+   * Delete the selected node from the current state.
+   */
+  handleEvent(): void;
+  /**
+   * Handles the deletion of content within a single block in an RTE editor.
+   */
+  private deleteContentWithSingleBlock;
+  /**
+   * Creates a new paragraph element with a text node and appends it to the current state.
+   */
+  private insertDefaultParagraph;
+  /**
+   * Deletes the content within multiple nodes selected by the user.
+   */
+  private deleteContentWithMultipleNodes;
+  /**
+   * If the first block is not paragraph, convert the block to paragraph after delete all text
+   *
+   * @param {RTEBlock} block - The first block instance
+   */
+  private convertFirstBlockToParagraph;
+  /**
+   * Returns the end offset of a given node in a Rich Text Editor based on its type and text content.
+   *
+   * @param {RTENode} node - text node or image node
+   * @returns {number} Returns a number value.
+   */
+  private getNodeEndOffset;
+}

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

@@ -0,0 +1,53 @@
+import { BaseHandler } from './base-handler';
+/** 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
+   */
+  handleEvent(): void;
+  /**
+   * Insert the \n in text element when root container is empty, should create text block and text node
+   * <p>
+   *  <span></span>
+   *  <span></span>
+   * </p>
+   */
+  private breakNewBlock;
+  /**
+   * If the selected node is a text node
+   * <p>
+   *  <span>text</span>
+   * </p>
+   * Insert a line break and the selected node will be split into three text nodes
+   * <p>
+   *  <span>te</span>
+   *  <br>
+   *  <span>xt</span>
+   * </p>
+   */
+  private breakSingleBlock;
+  /**
+   * Handles breaking blocks in an RTE editor based on the current selection and position.
+   */
+  private breakMultipleBlocks;
+  /**
+   * Moves the caret to the next node element in a rich text editor.
+   *
+   * @param {RTETextNode} lineBreakNode - Represents a node element in a rich text editor.
+   */
+  private switchCaretPositionToSpecifiedNode;
+  /**
+   * Returns the next sibling node of a given block element in a rich text editor.
+   *
+   * @param {RTENode} lineBreakNode - The `lineBreakNode` parameter is of type `RTENode`, which is used to represent the new line break element in a rich text editor.
+   * @returns {RTENode} The next sibling node of the current line break element, or the current node if next node is not exists.
+   */
+  private getNextRTENode;
+  /**
+   * Create a null text that will render a br element in a rich text editor.
+   *
+   * @param {RTEBlock} block - Represents a block element in a rich text editor.
+   * @returns {RTETextNode} the new line break node.
+   */
+  private createLineBreakNode;
+}

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

@@ -0,0 +1,22 @@
+import { BaseHandler } from './base-handler';
+/** 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
+   */
+  handleEvent(): void;
+  /**
+   * Handles breaking blocks in an RTE editor based on the current selection and position.
+   */
+  private breakMultipleBlocks;
+  /**
+   * Handles breaking a single block in an RTE editor based on the current selection and position.
+   */
+  private breakSingleBlock;
+  /**
+   * Moves the caret to the next block element in a rich text editor.
+   *
+   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   */
+  private switchCaretPositionToNextElement;
+}

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

@@ -0,0 +1,44 @@
+import { BaseHandler } from './base-handler';
+/**
+ * Handle user paste
+ */
+export declare class InsertPasteHandler extends BaseHandler {
+  private elementToDTOProcessor;
+  /**
+   * Update the state value when user paste html elements.
+   *
+   * @param {InputEvent} event - Paste event.
+   */
+  handleEvent(event: InputEvent): void;
+  /**
+   * Insert the blocks to root
+   *
+   * @param { RTEContentBlock[]} blocks - blocks
+   */
+  private insertBlocksToRoot;
+  /**
+   * Insert the blocks to content
+   *
+   * @param { RTEContentBlock[]} blocks - blocks
+   */
+  private insertBlocksToContent;
+  /**
+   * Insert the blocks before to current block
+   *
+   * @param { RTEContentBlock[]} blocks - blocks
+   */
+  private insertBlocksBeforeEmptyBlock;
+  /**
+   * Format and parse elements from user paste.
+   *
+   * @param {InputEvent} event - Paste event.
+   * @returns {RTEContentBlock[]} - RTEContentBlock.
+   */
+  private parsePastedElements;
+  /**
+   * Moves the caret to the next block element in a rich text editor.
+   *
+   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   */
+  private switchCaretPositionToNextElement;
+}

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

@@ -0,0 +1,25 @@
+import { BaseHandler } from './base-handler';
+/** 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
+   */
+  handleEvent(event: InputEvent): void;
+  /**
+   * 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
+   */
+  private insertTextToRoot;
+  /**
+   * Insert text to a line break node need a special logic if the line break has a next text node.
+   *
+   * @param {RTETextNode} lineBreakNode The current line break node, the text value is \n
+   * @param {string} text The text need to insert
+   * @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/insert-image-controller.d.ts

@@ -0,0 +1,39 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { RTEImageNode } from '../../dto/nodes/image-node';
+/** Used to control the insert image tool button actions */
+export declare class InsertImageController extends VegaSlimmer {
+  protected selectionController: VegaRichTextEditor['selectionController'];
+  protected value: VegaRichTextEditor['value'];
+  protected valueController: VegaRichTextEditor['valueController'];
+  protected vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
+  /**
+   * Insert a image to current state
+   *
+   * @param {string} imageUrl The image url
+   * @returns {RTEImageNode} RTEImageNode
+   */
+  insertImageToCaretPosition(imageUrl: string): RTEImageNode;
+  /**
+   * Add image selected observer
+   */
+  protected registerObserver(): void;
+  /**
+   * remove the observer when component removed
+   */
+  protected unRegisterObserver(): void;
+  /**
+   * Updates the caret position to the parent element of a new image node.
+   *
+   * @param {RTEImageNode} newImageNode - An image node in a rich text editor.
+   */
+  private updateCaretPosition;
+  /**
+   * The current selected node should be current image node after click image.
+   */
+  private registerImageSelectedObserver;
+  /**
+   * remove the observer after component delete
+   */
+  private removeImageSelectedObserver;
+}

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

@@ -0,0 +1,13 @@
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+/**
+ * The rich text content controller
+ */
+export declare class RichTextContentController {
+  private readonly editor;
+  constructor(editor: VegaRichTextEditor);
+  /**
+   * Sync rich text content editable with disabled property
+   *
+   */
+  syncRichTextContentEditable(): void;
+}

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

@@ -0,0 +1,123 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { RTEBlock } from '../../dto/blocks/block.abstract';
+import { RTENode } from '../../dto/nodes/node.abstract';
+import { RTERange } from '../../dto/range';
+declare type SelectionStateType = {
+  startNode: Node | RTENode;
+  endNode: Node | RTENode;
+  startOffset: number;
+  endOffset: number;
+};
+/**
+ * The text selection controller
+ */
+export declare class SelectionController extends VegaSlimmer {
+  static readonly SELECTION_CHANGE_DEBOUNCE_TIME: number;
+  vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
+  selectionMap: VegaRichTextEditor['selectionMap'];
+  host: VegaRichTextEditor['host'];
+  protected readonly value: VegaRichTextEditor['value'];
+  protected readonly valueController: VegaRichTextEditor['valueController'];
+  private currentRange;
+  private updateCaretPositionTaskQueue;
+  private handleSelectionWithDebounce;
+  private selectedNodes;
+  private selectionRangeChangeObserver;
+  /**
+   * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.connectedCallback}
+   */
+  connectedCallback(): void;
+  /**
+   * Component lifecycle - [disconnectedCallback]{@link VegaRichTextEditor.disconnectedCallback}
+   */
+  disconnectedCallback(): void;
+  /**
+   * Component lifecycle - [componentDidLoad]{@link VegaRichTextEditor.componentDidLoad}
+   */
+  componentDidLoad(): void;
+  /**
+   * Watches the internal value of the editor
+   */
+  watchValueUpdate(): void;
+  /**
+   * Update the caret position after the component re-render
+   */
+  updateCaretPosition(): Promise<void>;
+  /**
+   * Get the current RTE selection range
+   *
+   * @returns {RTERange} - The current RTE selection range
+   */
+  getCurrentRange(): RTERange;
+  /**
+   * Get the selected rich text node
+   *
+   * @returns {RTENode[]} Selected rich text nodes
+   */
+  getSelectedNodes(): RTENode[];
+  /**
+   * Get the selected rich text blocks
+   *
+   * @returns {RTEBlock[]} Selected rich text blocks
+   */
+  getSelectedBlocks(): RTEBlock[];
+  /**
+   * Sets the next selection state with specified start and end nodes, offsets, push the update task to a queue
+   *
+   * @param {SelectionStateType['startNode']} startNode - The starting node of the selection range. It is a Node object representing the node where the selection range starts.
+   * @param {number} startOffset - The `startNode` where the selection range should start. It indicates the position within the `startNode` where the selection should begin.
+   * @param {SelectionStateType['endNode']} [endNode] - The ending node of the selection range. If a value is provided for `endNode`, it will be used as the ending node of the selection range.
+   * @param {number} [endOffset] - The ending offset within the `endNode` where the selection range should end.
+   * @param {boolean} [immediatelyRun] - Should the task run immediately. default is false
+   */
+  enqueueSelectionRangeFutureState(startNode: SelectionStateType['startNode'], startOffset: number, endNode?: SelectionStateType['endNode'], endOffset?: number, immediatelyRun?: boolean): void;
+  /**
+   * Set selection with a new range
+   *
+   * @param {Range} range - The range to set
+   */
+  setSelectionRange(range: Range): void;
+  /**
+   * Save the current selection range detail
+   */
+  private saveSelection;
+  /**
+   * Restore the selection to the current selected nodes
+   */
+  private restoreSelection;
+  /**
+   * Get the rich text content selected range
+   *
+   * @returns {Selection} A [Selection](https://developer.mozilla.org/en-US/docs/Web/API/Selection) object
+   */
+  private getSelection;
+  /**
+   * Get selected rich text
+   */
+  private handleSelectionChange;
+  /**
+   * Clear the selection map
+   */
+  private clearSelectionMap;
+  /**
+   * Sets the next selection state with specified start and end nodes, offsets, and a timestamp.
+   *
+   * Example:
+   * Before insert text start offset is 0, the new start offset should update to 1
+   * Before delete text start offset is 1, the new start offset should update to 0
+   *
+   */
+  private createUpdateSelectionRangeTask;
+  /**
+   * Check if the selection range change is acceptable
+   *
+   * @returns {boolean} - Returns a boolean value.
+   */
+  private isAcceptableSelectionRangeChange;
+  /**
+   * Register the selection range change observer
+   */
+  private registerSelectionRangeChangeObserver;
+}
+export {};

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/state-entity-rendering-registry.d.ts

@@ -0,0 +1,33 @@
+import { RTEBlock } from '../../dto/blocks/block.abstract';
+import { RTENode } from '../../dto/nodes/node.abstract';
+import { Nullable } from '../../../../types/general';
+/**
+ * This class is responsible for keeping track of the DOM elements and their corresponding entities.
+ */
+declare class StateEntityRenderingRegistry {
+  domToEntity: WeakMap<HTMLElement, RTEBlock | RTENode>;
+  entityToDOM: WeakMap<RTEBlock | RTENode, HTMLElement>;
+  /**
+   * Registers a DOM element and its corresponding entity.
+   *
+   * @param {HTMLElement} dom The DOM element to register.
+   * @param {RTEBlock | RTENode} entity The entity to register.
+   */
+  register(dom: HTMLElement, entity: RTEBlock | RTENode): void;
+  /**
+   * Retrieves the entity corresponding to a DOM element.
+   *
+   * @param {HTMLElement} dom The DOM element to retrieve the entity for.
+   * @returns {Nullable<RTEBlock | RTENode>} The entity corresponding to the DOM element, or null if not found.
+   */
+  getEntityByDOM(dom: HTMLElement): Nullable<RTEBlock | RTENode>;
+  /**
+   * Retrieves the DOM element corresponding to an entity.
+   *
+   * @param {RTEBlock | RTENode} entity The entity to retrieve the DOM element for.
+   * @returns {Nullable<HTMLElement>} The DOM element corresponding to the entity, or null if not found.
+   */
+  getDOMByEntity(entity: RTEBlock | RTENode): Nullable<HTMLElement>;
+}
+declare const _default: StateEntityRenderingRegistry;
+export default _default;

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

@@ -0,0 +1,22 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+/**
+ * Controller for the text node color
+ */
+export declare class TextNodeColorController extends VegaSlimmer {
+  private observer;
+  /**
+   * Component lifecycle - [connectedCallback]
+   * Register an observer to watch for dark mode updates, which will update the color of text node .
+   */
+  connectedCallback(): void;
+  /**
+   * cancel dark mode observer when disconnectedCallback
+   */
+  disconnectResizeObserver(): void;
+  /**
+   * Determines whether the observer should accept changes.
+   *
+   * @returns {boolean} Always returns true in the current implementation.
+   */
+  private isAcceptObserver;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/text-node-rendering-registry.d.ts

@@ -0,0 +1,22 @@
+import { TextColorAnnotation } from '../../dto/annotations/text-color-annotation';
+/**
+ * This class is responsible for keeping track of the DOM elements.
+ */
+declare class TextNodeRenderingRegistry {
+  private textNodeElements;
+  /**
+   * Registers a DOM element and the color annotation of the DOM element.
+   *
+   * @param {HTMLElement} dom The DOM element to register.
+   * @param {TextColorAnnotation} textColorAnnotation The text color annotation of text node to register.
+   */
+  register(dom: HTMLElement, textColorAnnotation: TextColorAnnotation): void;
+  /**
+   * Retrieves the text node elements.
+   *
+   * @returns {HTMLElement[]} The text node elements, or empty array.
+   */
+  getTextNodeElements(): Map<HTMLElement, TextColorAnnotation>;
+}
+declare const _default: TextNodeRenderingRegistry;
+export default _default;

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

@@ -0,0 +1,70 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+/** Used to monitoring the user input actions by event listener and mutationObserver */
+export declare class UserInputController extends VegaSlimmer {
+  protected host: VegaRichTextEditor['host'];
+  protected value: VegaRichTextEditor['value'];
+  protected valueController: VegaRichTextEditor['valueController'];
+  protected vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
+  protected selectionController: VegaRichTextEditor['selectionController'];
+  private editableElementRef;
+  private insertTextHandler;
+  private insertParagraphHandler;
+  private insertLineBreakHandler;
+  private deleteContentHandler;
+  private insertPasteHandler;
+  private mutationObserver;
+  private observerOptions;
+  /**
+   * The function `initMutationObserver` initializes a MutationObserver on an editable HTML element if it exists.
+   */
+  initMutationObserver(): void;
+  /**
+   * Disconnects the mutation observer if it exists.
+   */
+  removeObserver(): void;
+  /**
+   * Adds event listener to an editable HTML element to handle user input actions.
+   */
+  protected addActionListener(): void;
+  /**
+   * Removes event listener for user input actions from an editable HTML div element.
+   */
+  protected removeActionListener(): void;
+  /**
+   * re-connect the observer after the props change and component did render
+   */
+  protected reConnectObserver(): void;
+  /**
+   * When a user performs an input action within the editable element, this function is triggered.
+   *
+   * @param {InputEvent} e the before input event object
+   */
+  private handleUserInputAction;
+  /**
+   * The function `getEditableElementRef` returns a reference to the editable HTMLDivElement within a rich text editor.
+   *
+   * @returns {HTMLDivElement|null} A reference to an HTMLDivElement element that is editable.
+   */
+  private getEditableElementRef;
+  /**
+   * Notifies a change manager with the host and value details and logs the current value.
+   */
+  private notifyComponentFlushValue;
+  /**
+   * Processes mutation records related to character data and updates the text content of a rich text node accordingly.
+   *
+   * @param {MutationRecord[]} records - Each `MutationRecord` object represents a single mutation that occurred in the DOM.
+   */
+  private handleObserver;
+  /**
+   * Prevents the default behavior of a drag event.
+   *
+   * @param {DragEvent} e - drop event object
+   */
+  private preventDropEvent;
+  /**
+   * Initializes the value to an empty array if it is currently empty.
+   */
+  private initValueIfEmpty;
+}

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

@@ -0,0 +1,38 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { VegaRTEContent } from '../../dto/content-state';
+/**
+ * The value controller is responsible for updating the value of the rich text editor.
+ */
+export declare class ValueController extends VegaSlimmer {
+  static readonly VALUE_CHANGE_DEBOUNCE_TIME: number;
+  host: VegaRichTextEditor['host'];
+  value: VegaRichTextEditor['value'];
+  changeEventEmitter: VegaRichTextEditor['changeEventEmitter'];
+  valueController: VegaRichTextEditor['valueController'];
+  private flushChangeObserver;
+  /**
+   * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.connectedCallback}
+   */
+  connectedCallback(): void;
+  /**
+   * Component lifecycle - [connectedCallback]{@link VegaRichTextEditor.disconnectedCallback}
+   */
+  disconnectedCallback(): void;
+  /**
+   * Watches the value of the editor and updates the internal value.
+   */
+  watchValueUpdate(): void;
+  /**
+   * Updates the value of the editor and restore the selection.
+   *
+   * @param {VegaRTEContent} newValue The new value to set.
+   */
+  flushChanges(newValue: VegaRTEContent): Promise<void>;
+  /**
+   * Determines whether the observer should accept changes.
+   *
+   * @returns {boolean} Always returns true in the current implementation.
+   */
+  private isAcceptableFlushChange;
+}