@globalpayments/vega 2.61.0 → 2.62.0

package/dist/types/components/vega-rich-text-editor/extensions/languages/language-extension.d.ts

@@ -0,0 +1,50 @@
+import { RTEDropdownListItem, RTEExtensionContext, RTELanguageExtensionState } from '../../interface';
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Language extension for Vega Rich Text Editor.
+ * This extension allows users to switch between different languages and maintain separate content for each language.
+ */
+export declare class VegaRTELanguageExtension extends VegaRTEExtension {
+  private languageToolbarButtonRenderer;
+  private languageState;
+  constructor(languageList: RTEDropdownListItem[], languagesState?: RTELanguageExtensionState);
+  /**
+   * Initializes the language extension.
+   * Applies the content for the selected language upon initialization.
+   *
+   * @param {RTEExtensionContext} context The extension context.
+   */
+  initialExtension(context: RTEExtensionContext): void;
+  /**
+   * Invoked to set the language extension state. The method used if the state can not be provide when the editor is initialized.
+   *
+   * @param {RTELanguageExtensionState} state The language extension state to set.
+   */
+  setState(state: RTELanguageExtensionState): void;
+  /**
+   * Invoked to get the language extension state.
+   *
+   * @returns {RTELanguageExtensionState} The current language extension state.
+   */
+  getState(): RTELanguageExtensionState;
+  /**
+   * Listener for language change events from the toolbar button renderer.
+   *
+   * @param {string} selectedLanguage - The newly selected language.
+   */
+  private languageChangeCallBack;
+  /**
+   * Applies the content for the selected language.
+   *
+   * @param {string} selectedLanguage - The newly selected language.
+   * @param {RTELanguageExtensionState['contentMap']} contentMap - The content map for all languages.
+   */
+  private applyLanguageContent;
+  /**
+   * Get the RTE latest value. The value is from the code block when in source edit mode; otherwise, it's from the host value.
+   *
+   * @param {HTMLElement} host - The host element of the rich text editor.
+   * @returns {VegaRTEContent} - The content.
+   */
+  private getRTELatestValue;
+}

package/dist/types/components/vega-rich-text-editor/extensions/languages/language-toolbar-button-renderer.d.ts

@@ -0,0 +1,54 @@
+import { RTEDropdownListItem, VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+export declare type LanguageSelectedCallback = (selectedLanguage: string) => void;
+/**
+ * Toolbar button renderer for language selection in Vega Rich Text Editor.
+ */
+export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private languageList;
+  private selectedLanguage;
+  private labelRef;
+  private languageChangeCallback;
+  constructor(languageList: RTEDropdownListItem[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage: string);
+  /**
+   * Public method to set the selected language.
+   *
+   * @param {string} language The language key to set as selected.
+   */
+  setSelectedLanguage(language: string): void;
+  /**
+   * The source edit mode does not affect the language button visibility.
+   *
+   * @returns {boolean} True if the button is hidden, false otherwise.
+   */
+  isHidden(): boolean;
+  /**
+   * @inheritDoc
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Override to render the button label with custom behavior.
+   *
+   * @inheritDoc
+   */
+  protected renderButtonLabel(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext, label: string): VegaRTERenderResult;
+  /**
+   * Handles the button click event. No need this method for language button.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Handles the language selection event.
+   *
+   * @param {string} itemKey - The key of the selected language item.
+   */
+  protected handleDropdownClick: (itemKey: string) => void;
+  /**
+   * Gets the label of a language by its key.
+   *
+   * @param {string} key The language key to look up.
+   * @returns {string} The label of the language, or the key if not found.
+   */
+  private getLanguageLabelByKey;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/insert-token-node-action.d.ts

@@ -0,0 +1,16 @@
+import { Nullable } from '../../../../types/general';
+import { ModifyContentAction } from '../../dto/actions/modify-content-action.abstract';
+import { RTERange } from '../../dto/range';
+import { RTEDropdownListItem } from '../../interface';
+/**
+ * Action to insert a token node at a specified range in the Rich Text Editor.
+ *
+ * @example block.apply(new InsertTokenNodeAction(rteRange, tokenNode));
+ */
+export declare class InsertTokenNodeAction extends ModifyContentAction {
+  type: string;
+  token: RTEDropdownListItem;
+  rteRange: Nullable<RTERange>;
+  actionHandleResult: boolean;
+  constructor(rteRange: Nullable<RTERange>, token: RTEDropdownListItem);
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/insert-token-node-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import type { RTETextBlock } from '../../dto/blocks/text-block';
+import { InsertTokenNodeAction } from './insert-token-node-action';
+/**
+ * Strategy to handle the insertion of a token node into the nearest root block.
+ */
+export declare class InsertTokenNodeStrategy extends ActionHandleStrategy<InsertTokenNodeAction, RTETextBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTokenNodeAction, block: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/span-to-token-node-strategy.d.ts

@@ -0,0 +1,24 @@
+import { Nullable } from '../../../../types/general';
+import { VegaRTECustomNode } from '../../interface';
+import { ElementToDTOStrategy } from '../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+/**
+ * Strategy to convert <span class="token" token-key="...">...</span> to a token node
+ */
+export declare class SpanToTokenNodeStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-extension.d.ts

@@ -0,0 +1,14 @@
+import { RTEDropdownListItem, RTEExtensionContext } from '../../interface';
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Vega Rich Text Editor Token Extension
+ */
+export declare class VegaRTETokenExtension extends VegaRTEExtension {
+  private tokenRenderer;
+  private tokenToolbarButtonRenderer;
+  constructor(tokenList?: RTEDropdownListItem[]);
+  /**
+   * @inheritDoc
+   */
+  initialExtension(context: RTEExtensionContext): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-node-renderer.d.ts

@@ -0,0 +1,38 @@
+import { RTEExtensionContext, RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../interface';
+import { VegaRTEExtensionRenderer } from '../base-extension-renderer';
+import { RTETokenNode } from './token-node';
+/**
+ * Token node renderer for the rich text editor.
+ */
+export declare class RTETokenNodeRenderer extends VegaRTEExtensionRenderer {
+  private extensionContext;
+  /**
+   * Renders the token node as a DOM element.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create a DOM element.
+   * @param {RTETokenNode} node - The token node to render.
+   * @param {RTERenderContext} editorContent - The editor content context.
+   * @returns {VegaRTERenderResult} - The rendered DOM element.
+   */
+  doRender(createElement: VegaRTECreateElementFunction, node: RTETokenNode, editorContent?: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Sets the RTE extension context.
+   *
+   * @param {RTEExtensionContext} context - The context of the RTE extension.
+   */
+  injectExtensionContext(context: RTEExtensionContext): void;
+  /**
+   * Get the style for the token element.
+   *
+   * @param {RTETokenNode} node - The token node.
+   * @returns {Record<string, string>} The style object for the token element.
+   */
+  protected getStyle(node: RTETokenNode): Record<string, string>;
+  /**
+   * Handle the click event on the token element.
+   *
+   * @param {MouseEvent} event - The click event.
+   * @param {RTETokenNode} node - The token node that was clicked.
+   */
+  private handleTokenElementClick;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-node.d.ts

@@ -0,0 +1,39 @@
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { RTETextNode } from '../../dto/nodes/text-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETokenNode } from '../../interface';
+/**
+ * Token node for the Vega Rich Text Editor.
+ */
+export declare class RTETokenNode extends RTETextNode {
+  type: string;
+  token: string;
+  constructor(id: string, token: string, text: string, parentBlock: RTETextBlock, annotations?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTETokenNode, parent: RTETextBlock): RTETokenNode;
+  /**
+   * Converts the token node to a JSON representation.
+   *
+   * @returns {VegaRTETokenNode} - The JSON representation of the token node.
+   */
+  toJSON(): VegaRTETokenNode;
+  /**
+   * Determines if the token node is content editable.
+   *
+   * @returns {boolean} - Always returns false for token nodes.
+   */
+  isContentEditable(): boolean;
+  /**
+   * Clones the token node.
+   *
+   * @returns {RTETokenNode} - The cloned token node.
+   */
+  clone(): RTETokenNode;
+  /**
+   * Converts the token node to an HTML representation.
+   *
+   * @returns {string} - The HTML representation of the token node.
+   */
+  toHtml(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-toolbar-button-renderer.d.ts

@@ -0,0 +1,47 @@
+import { RTEExtensionContext, VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult, RTEDropdownListItem } from '../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+/**
+ * Renderer for the token toolbar button in the Vega Rich Text Editor.
+ */
+export declare class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private tokenList;
+  private extensionContext;
+  constructor(tokenList: RTEDropdownListItem[]);
+  /**
+   * Sets the RTE extension context.
+   *
+   * @param {RTEExtensionContext} context - The context of the RTE extension.
+   */
+  injectExtensionContext(context: RTEExtensionContext): void;
+  /**
+   * Renders the token toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} createElement Function to create elements in the rich text editor.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @returns {VegaRTERenderResult} Token toolbar button.
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Checks if the token toolbar button is disabled.
+   *
+   * @returns {boolean} True if the button is disabled, false otherwise.
+   */
+  protected isDisabled(): boolean;
+  /**
+   * Handles the button click event. No need this method for token button.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Handles the token item click event from the dropdown.
+   *
+   * @param {string} itemKey - The key of the clicked token item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleDropdownClick(itemKey: string, editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Refreshes the editor UI.
+   */
+  private flushEditorUI;
+}

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

@@ -18,6 +18,7 @@ import { RTEHtmlBlock } from './dto/blocks/html-block';
 import { InlineHtmlAnnotation } from './dto/annotations/inline-html-annotation';
 import type { RTERange } from './dto/range';
 import type { RTENode } from './dto/nodes/node.abstract';
+import type { VegaRTEContent } from './dto/content-state';
 
 export type ToolbarButtonConfig = {
 	icon: string;
@@ -302,7 +303,7 @@ export type VegaRTECreateElementFunction = <
 	children?: VegaRTERenderNode | VegaRTERenderNode[],
 ) => VegaRTERenderResult;
 
-export type VegaRTEExtensionContext = {
+export type VegaRTEToolbarRenderContext = {
 	host: HTMLVegaRichTextEditorElement;
 	rteRange: RTERange;
 	sourceEditMode: boolean;
@@ -320,3 +321,53 @@ export type FocusNodeRangeState = {
 	startNode: RTENode;
 	startOffset: number;
 };
+
+export type RTEExtensionContext = {
+	host: HTMLVegaRichTextEditorElement;
+	/**
+	 * Check if the editor is in source edit mode.
+	 *
+	 * @returns {boolean} - Whether the editor is in source edit mode.
+	 */
+	isSourceEditMode: () => boolean;
+	/**
+	 * Get the currently selected nodes in the editor.
+	 *
+	 * @returns {RTENode[]} - An array of currently selected RTENode objects.
+	 */
+	getSelectedNodes: () => RTENode[];
+	/**
+	 * Flush the editor value to the host. Auto focus the last node if autoFocusLastNode is true.
+	 * Sometimes, the editor will lose focus after change the editor value, so we need to focus the last node again.
+	 * Or apply the update cursor position action to focus the cursor to the specified position.
+	 *
+	 * @example flushValue(newValue, true);
+	 * @example flushValue(newValue); host.value.apply(new UpdateCursorPositionAction(node, offset));
+	 * @param {VegaRTEContent} value - The content value to flush.
+	 * @param {boolean} autoFocusLastNode - Whether to auto-focus the last node after flushing.
+	 */
+	flushValue: (value: VegaRTEContent, autoFocusLastNode?: boolean) => void;
+};
+
+export type RTEToolbarButtonProps = {
+	icon?: string;
+	label?: string;
+	showArrowIcon?: boolean;
+};
+
+export type RTEDropdownListItem = { key: string; label: string; icon?: string };
+
+export type RTEToolbarDropdownProps = {
+	source?: RTEDropdownListItem[];
+	selectType?: 'none' | 'single';
+	selectedSourceKey?: string;
+	maxHeight?: number;
+	alignment?: 'start' | 'center' | 'end';
+};
+
+export type RTELanguageContentMap = Record<string, VegaRTEContent | VegaRTEContentBlock[] | undefined>;
+
+export type RTELanguageExtensionState = {
+	selectedLanguage: string;
+	contentMap: RTELanguageContentMap;
+};

package/dist/types/components/vega-rich-text-editor/public-api.d.ts

@@ -0,0 +1,29 @@
+export { VegaRTEContent } from './dto/content-state';
+export { RTENode } from './dto/nodes/node.abstract';
+export { RTEDecoratorNode } from './dto/nodes/decorator-node';
+export { RTETextNode } from './dto/nodes/text-node';
+export { RTETextBlock } from './dto/blocks/text-block';
+export { RTEBlock } from './dto/blocks/block.abstract';
+export { VegaRTEExtension } from './extensions/extension.abstract';
+export { VegaRTEExtensionRenderer } from './extensions/base-extension-renderer';
+export { VegaRTEToolbarButtonRenderer } from './extensions/base-toolbar-button-renderer';
+export { RTETokenToolbarButtonRenderer } from './extensions/tokens/token-toolbar-button-renderer';
+export { RTETokenNode } from './extensions/tokens/token-node';
+export { RTETokenNodeRenderer } from './extensions/tokens/token-node-renderer';
+export { VegaRTETokenExtension } from './extensions/tokens/token-extension';
+export { RTELanguageToolbarButtonRenderer } from './extensions/languages/language-toolbar-button-renderer';
+export { VegaRTELanguageExtension } from './extensions/languages/language-extension';
+export { ModifyContentAction } from './dto/actions/modify-content-action.abstract';
+export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';
+export { RemoveChildrenAction } from './dto/actions/remove-child-action';
+export { InsertChildrenAfterAction } from './dto/actions/insert-children-after-block';
+export { InsertChildrenBeforeAction } from './dto/actions/insert-children-before-block';
+export { InsertNodeToNearestRootAction } from './dto/actions/insert-node-to-nearest-root-action';
+export { UpdateCursorPositionAction } from './dto/actions/update-cursor-position-action';
+export { CustomAttributeAnnotation } from './dto/annotations/custom-attribute-annotation';
+export { CustomClassAnnotation } from './dto/annotations/custom-class-annotation';
+export { CustomStyleAnnotation } from './dto/annotations/custom-style-annotation';
+export { ActionHandleStrategy } from './dto/action-handle-strategies/action-handle-strategy.abstract';
+export { RTERange } from './dto/range';
+export { ElementToDTOStrategy } from './slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+export { VegaRTEPresetToolbarItems } from './constants/constant';

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

@@ -0,0 +1,44 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { VegaRTEExtension } from '../../extensions/extension.abstract';
+/**
+ * Inject the editor context to the extensions.
+ */
+export declare class RTEExtensionController extends VegaSlimmer {
+  protected extensions: VegaRichTextEditor['extensions'];
+  protected host: HTMLVegaRichTextEditorElement;
+  protected sourceView: VegaRichTextEditor['sourceView'];
+  protected valueController: VegaRichTextEditor['valueController'];
+  protected selectionController: VegaRichTextEditor['selectionController'];
+  /**
+   * Initializes the extension context for all registered extensions.
+   * This method is called when the component is connected and whenever the extensions property changes.
+   */
+  protected initialExtensionContext(): void;
+  /**
+   * Update extension context when extensions property changes.
+   *
+   * @param {VegaRTEExtension[]} newValue - New extensions array.
+   * @param {VegaRTEExtension[]} oldValue - Old extensions array.
+   */
+  protected handleExtensionsChange(newValue: VegaRTEExtension[], oldValue: VegaRTEExtension[]): void;
+  /**
+   * Flush the editor value to the host. Auto focus the last node if autoFocusLastNode is true.
+   *
+   * @param {VegaRTEContent} value - The content value to flush.
+   * @param {boolean} autoFocusLastNode - Whether to auto-focus the last node after flushing.
+   */
+  private flushValue;
+  /**
+   * Check if the editor is in source edit mode.
+   *
+   * @returns {boolean} - Whether the editor is in source edit mode.
+   */
+  private isSourceEditMode;
+  /**
+   * Get the currently selected nodes in the editor.
+   *
+   * @returns {RTENode[]} - An array of currently selected RTENode objects.
+   */
+  private getSelectedNodes;
+}

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

@@ -1,10 +1,19 @@
 import { Nullable } from '../../../../../../types/general';
-import { RTEContentBlock, VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../interface';
+import { RTEContentBlock, VegaRTEAnnotations, VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../interface';
 import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { HtmlElementToAnnotationGenerateOptions } from './annotation-handler/html-element-to-annotation-generator';
 /**
  * Abstract class to define strategies for processing HTML elements
  */
 export declare abstract class ElementToDTOStrategy {
+  /**
+   * Convert element style attributes to text annotations.
+   *
+   * @param {HTMLElement} element - Current html element.
+   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for generating annotations.
+   * @returns {VegaRTEAnnotations} - Generated annotations.
+   */
+  protected generateTextStyleAnnotations(element: HTMLElement, options?: HtmlElementToAnnotationGenerateOptions): VegaRTEAnnotations;
   abstract canHandle(elementsArray: HTMLElement[], currentIndex: number, options: VegaRTETransformOptions): number;
   abstract handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions, parentTextAnnotations?: VegaRTETextAnnotations): Nullable<RTEBlock | VegaRTECustomNode>;
   abstract appendChildBlocks(currentBlock: RTEContentBlock, childBlocks: RTEContentBlock[]): void;

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/toolbar-renderer.d.ts

@@ -25,4 +25,10 @@ export declare class ToolbarRenderer extends VegaSlimmer {
   render(): HTMLElement;
   private getToolbarBtnRenderer;
   private renderVegaDivider;
+  /**
+   * Renders the toolbar items based on the configured toolbar groups and items.
+   *
+   * @returns {[HTMLElement[], number]} A tuple containing the rendered toolbar items and the count of displayed items.
+   */
+  private renderToolbarItems;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/toolbar-button-slimmer.abstract.d.ts

@@ -16,6 +16,10 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
   private readonly autoFocusOnClick;
   protected constructor({ icon, tooltip, autoFocusOnClick }: ToolbarButtonConfig);
   setIcon(icon: string): void;
+  /**
+   * Whether the button is hidden or not.
+   */
+  isHidden(): boolean;
   render(): HTMLElement;
   /**
    * The wrapper for the button.
@@ -36,10 +40,6 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
    * Whether the button is disabled or not.
    */
   protected isDisabled(): boolean;
-  /**
-   * Whether the button is hidden or not.
-   */
-  protected isHidden(): boolean;
   protected preventLostFocus(): {
     onMouseDown: (e: Event) => void;
   };

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/visual-mode-toolbar-button-slimmer.abstract.d.ts

@@ -7,6 +7,13 @@ import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 export declare abstract class VisualModeToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   protected readonly sourceView: VegaRichTextEditor['sourceView'];
   protected constructor(config: ToolbarButtonConfig);
+  /**
+   * Determines if the button should be hidden.
+   * Hide the button when the editor is in source view mode, except for the source edit button.
+   *
+   * @returns {boolean} - True if the button is hidden, false otherwise.
+   */
+  isHidden(): boolean;
   /**
    * Determines if the button should be disabled.
    * Determines whether should disable the button or not when the editor is not in source view mode, except for the source edit button.
@@ -14,11 +21,4 @@ export declare abstract class VisualModeToolbarButtonSlimmer extends ToolbarButt
    * @returns {boolean} - True if the button is disabled, false otherwise.
    */
   protected isDisabled(): boolean;
-  /**
-   * Determines if the button should be hidden.
-   * Hide the button when the editor is in source view mode, except for the source edit button.
-   *
-   * @returns {boolean} - True if the button is hidden, false otherwise.
-   */
-  protected isHidden(): boolean;
 }

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

@@ -42,6 +42,8 @@ import { HistoryController } from './slimmers/controllers/history-controller';
 import { CodeBlockToolbarButtonSlimmer } from './slimmers/renderers/tools/code-block-toolbar-button-slimmer';
 import { InternalCodeBlockSelectionController } from './slimmers/controllers/internal-code-block-selection-controller';
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
+import { VegaRTEExtension } from './extensions/extension.abstract';
+import { RTEExtensionController } from './slimmers/controllers/extension-controller';
 /**
  * @vegaVersion 2.34.0
  */
@@ -85,6 +87,7 @@ export declare class VegaRichTextEditor {
   protected readonly deleteSelectedNodesController: DeleteSelectedNodesController;
   protected readonly historyController: HistoryController;
   protected readonly internalCodeBlockSelectionController: InternalCodeBlockSelectionController;
+  protected readonly rteExtensionController: RTEExtensionController;
   host: HTMLVegaRichTextEditorElement;
   richTextContentEditable: boolean;
   watchRichTextContentEditable(): void;
@@ -186,6 +189,13 @@ export declare class VegaRichTextEditor {
    */
   validationRules: FormFieldValidationRule<unknown>[];
   watchValidationRules(): void;
+  /**
+   * Specifies the configuration for the rich text editor extensions.
+   *
+   * @vegaVersion 2.62.0
+   */
+  extensions: VegaRTEExtension[];
+  watchExtensions(): void;
   /**
    * An event emitter notifying a value change.
    *

package/dist/types/components.d.ts

@@ -50,6 +50,7 @@ import { VegaPageNotificationActionButtonConfig, VegaPageNotificationTypes } fro
 import { DropdownPropsForPagination, VegaPaginationItemType, VegaPaginationLayoutType } from "./components/vega-pagination/types";
 import { PieChartOptions } from "./helpers/chart/pie-chart";
 import { VegaRTEContent } from "./components/vega-rich-text-editor/dto/content-state";
+import { VegaRTEExtension } from "./components/vega-rich-text-editor/extensions/extension.abstract";
 import { VegaRichTextEditorImage, VegaRTESourceEditConfig, VegaRTEToolbarItem } from "./components/vega-rich-text-editor/interface";
 import { VegaRichTextImageEditorChangeDetail, VegaRichTextImageEditorSizeType } from "./components/vega-rich-text-editor/vega-rich-text-image-editor/types";
 import { VegaRichTextLinkEditorChangeDetail, VegaRichTextLinkEditorStatus, VegaRTELinkEditorRecord } from "./components/vega-rich-text-editor/vega-rich-text-link-editor/types";
@@ -3038,6 +3039,11 @@ export namespace Components {
           * @vegaVersion 2.34.0
          */
         "content": VegaRTEContent;
+        /**
+          * Defines the configuration for rich text content extensions. It enables support for custom nodes, ensuring that extended content is rendered correctly.
+          * @vegaVersion 2.62.0
+         */
+        "extensions": VegaRTEExtension[];
         /**
           * Invoke this method to focus on rich text content editable div
           * @vegaVersion 2.34.0
@@ -3060,6 +3066,11 @@ export namespace Components {
           * @vegaVersion 2.34.0
          */
         "disabled": boolean;
+        /**
+          * Specifies the configuration for the rich text editor extensions.
+          * @vegaVersion 2.62.0
+         */
+        "extensions": VegaRTEExtension[];
         /**
           * Provides a supplementary prompt message that assists users in    understanding the expected value within the rich text editor.
           * @vegaVersion 2.34.0
@@ -8926,6 +8937,11 @@ declare namespace LocalJSX {
           * @vegaVersion 2.34.0
          */
         "content"?: VegaRTEContent;
+        /**
+          * Defines the configuration for rich text content extensions. It enables support for custom nodes, ensuring that extended content is rendered correctly.
+          * @vegaVersion 2.62.0
+         */
+        "extensions"?: VegaRTEExtension[];
     }
     interface VegaRichTextEditor {
         /**
@@ -8943,6 +8959,11 @@ declare namespace LocalJSX {
           * @vegaVersion 2.34.0
          */
         "disabled"?: boolean;
+        /**
+          * Specifies the configuration for the rich text editor extensions.
+          * @vegaVersion 2.62.0
+         */
+        "extensions"?: VegaRTEExtension[];
         /**
           * Provides a supplementary prompt message that assists users in    understanding the expected value within the rich text editor.
           * @vegaVersion 2.34.0

package/dist/types/helpers/public-api.d.ts

@@ -15,4 +15,4 @@ export { waitForVega } from './common';
 export { IconPayload } from './icon/interface';
 export { VegaSkeletonLoader } from './skeleton-loader/vega-skeleton-loader-controller';
 export { VegaTranslation, en as VegaTranslationResourceEN } from './translation';
-export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
+export * from '../components/vega-rich-text-editor/public-api';

package/dist/types/types/components.type.d.ts

@@ -173,6 +173,7 @@ export {
 } from '../components/vega-pagination/types';
 export { PieChartOptions } from '../helpers/chart/pie-chart';
 export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
+export { VegaRTEExtension } from '../components/vega-rich-text-editor/extensions/extension.abstract';
 export {
 	VegaRichTextEditorImage,
 	VegaRTESourceEditConfig,

package/dist/types/types/public-api.d.ts

@@ -42,3 +42,14 @@ export { Breakpoints } from '../constants/tokens/breakpoints';
 export { GridColumns, GridRows } from '../constants/tokens/tailwind.extend';
 export { CodeLanguage } from '../components/vega-code-block/types';
 export { VegaTableColumnGroupingModel, VegaTableColumnGroupingLeafModel, } from '../components/vega-table/interface';
+export { DatePickerMonthYearType } from '../components/vega-date-picker/types';
+export type { AnnotationAction } from '../components/vega-rich-text-editor/dto/actions/annotation-action.abstract';
+export type { Annotation } from '../components/vega-rich-text-editor/dto/annotations/annotation.abstract';
+export type { VegaRTEBaseRenderer } from '../components/vega-rich-text-editor/dto/renderers/base-renderer';
+export type { BaseRenderer } from '../helpers/rte-manager/dto-renderer-manager';
+export type { RTEBlockParentType, RTEBlockChildrenType, } from '../components/vega-rich-text-editor/dto/blocks/block.abstract';
+export type { RTECodeBlock } from '../components/vega-rich-text-editor/dto/blocks/code-block';
+export type { RTEHtmlBlock } from '../components/vega-rich-text-editor/dto/blocks/html-block';
+export type { NodeAnnotations } from '../components/vega-rich-text-editor/dto/nodes/node.abstract';
+export type { BlockAnnotations } from '../components/vega-rich-text-editor/dto/blocks/block.abstract';
+export type { CustomAttributeAnnotation } from '../components/vega-rich-text-editor/dto/annotations/custom-attribute-annotation';