@globalpayments/vega 2.67.0 → 2.68.1

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

@@ -7,7 +7,9 @@ import { ElementToDTOStrategy } from '../slimmers/controllers/helper/element-to-
 import { Nullable } from '../../../types/general';
 import { RTEExtensionContext } from '../interface';
 import { ActionHandleStrategy } from '../dto/action-handle-strategies/action-handle-strategy.abstract';
-import { ModifyContentAction } from '../public-api';
+import { ModifyContentAction } from '../dto/actions/modify-content-action.abstract';
+import type { VegaRTEContent } from '../dto/content-state';
+import { ActionHandlerInterceptor } from '../dto/action-handle-strategies/action-handle-interceptor.abstract';
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -16,20 +18,36 @@ export declare abstract class VegaRTEExtension {
    * The context of the RTE extension, which may include references to the host editor and other relevant information.
    */
   protected extensionContext: Nullable<RTEExtensionContext>;
+  private hasCustomStylesRenderers;
   /**
    * Registers an action handle strategy for a specific node or block class.
    *
    * @param {string} nodeOrBlockClassName - The name of the node or block class.
    * @param {string} actionType - The type of the action.
-   * @param {ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock>} strategy - The strategy to register.
+   * @param {ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The strategy to register.
    */
-  static registerActionHandleStrategy(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock>): void;
+  static registerActionHandleStrategy(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandleStrategy<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>): void;
+  /**
+   * Registers an action handler interceptor for a specific node or block class.
+   *
+   * @param {string} nodeOrBlockClassName - The name of the node or block class.
+   * @param {string} actionType - The type of the action.
+   * @param {ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The interceptor to register.
+   */
+  static registerActionHandlerInterceptor(nodeOrBlockClassName: string, actionType: string, strategy: ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>): void;
   /**
    * Initializes the RTE extension with the provided context.
    *
    * @param {RTEExtensionContext} context - The context of the RTE extension.
    */
   initialExtension(context: RTEExtensionContext): void;
+  /**
+   * Collect custom styles for the extension renderers.
+   * If custom nodes have special styles, override this method to provide the styles.
+   *
+   * @returns {string} - The custom styles as a string.
+   */
+  collectExtensionRendererStyles(): string;
   /**
    * Register a node type with the extension.
    *
@@ -61,6 +79,21 @@ export declare abstract class VegaRTEExtension {
    * @param {string} blockClassName - The class name of the block to register strategies for.
    */
   protected registerBlockBasicStrategies(blockClassName: string): void;
+  /**
+   * Unregister a strategy for a specific action type and block class if not need.
+   *
+   * @param {string} actionType - The special action type or the action class name.
+   * @param {string} blockClassName - The class name of the block to unregister the strategy for.
+   */
+  protected unRegisterStrategy(actionType: string, blockClassName: string): void;
+  /**
+   * Unregister a strategy for a specific action type and block class if not need.
+   *
+   * @param {string} actionType - The special action type or the action class name.
+   * @param {string} blockClassName - The class name of the block to unregister the strategy for.
+   * @param {ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>} strategy - The interceptor to unregister.
+   */
+  protected unRegisterInterceptor(actionType: string, blockClassName: string, strategy: ActionHandlerInterceptor<ModifyContentAction, RTENode | RTEBlock | VegaRTEContent>): void;
   /**
    * Register an element to block DTO class strategy.
    *

package/dist/types/components/vega-rich-text-editor/extensions/functions/action-handler-interceptor/prevent-new-paragraph-interceptor.d.ts

@@ -0,0 +1,25 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { InsertNewParagraphAction } from '../../../dto/actions/insert-new-paragraph-action';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Prevent special type input in function block.
+ */
+export declare class PreventNewParagraphInterceptor extends ActionHandlerInterceptor<ModifyContentAction, RTETextBlock> {
+  /**
+   * Checks the target block parent whether is function block.
+   *
+   * @param {InsertNewParagraphAction} _action - the action to be intercepted
+   * @param {RTETextBlock} target - the target block
+   * @returns {boolean} - true if the target block parent is function block, false otherwise
+   */
+  canIntercept(_action: InsertNewParagraphAction, target: RTETextBlock): boolean;
+  /**
+   * Insert a new paragraph behind of the function block instead of the target block.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {ModifyContentAction} _action - the action to be intercepted
+   * @param {RTETextBlock} target - the target block
+   */
+  intercept(_execution: ActionHandlerExecution, _action: ModifyContentAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/action-handler-interceptor/prevent-paste-content-interceptor.d.ts

@@ -0,0 +1,17 @@
+import { ActionHandlerExecution } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { PreventNewParagraphInterceptor } from '../action-handler-interceptor/prevent-new-paragraph-interceptor';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+/**
+ * Prevent special type input in function block.
+ */
+export declare class PreventPasteContentInterceptor extends PreventNewParagraphInterceptor {
+  /**
+   * Paste plain text into text block.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {ModifyContentAction} action - the action to be intercepted
+   * @param {RTETextBlock} target - the target block
+   */
+  intercept(_execution: ActionHandlerExecution, action: ModifyContentAction, target: RTETextBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/action-handler-strategies/function-block-insert-paragraph-strategy.d.ts

@@ -0,0 +1,18 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertNewParagraphAction } from '../../../dto/actions/insert-new-paragraph-action';
+import { RTEFunctionBlock } from '../dto/function-block';
+/**
+ * Insert a new paragraph behind of current function block strategy.
+ */
+export declare class FunctionBlockInsertParagraphStrategy extends ActionHandleStrategy<InsertNewParagraphAction, RTEFunctionBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertNewParagraphAction, target: RTEFunctionBlock): void;
+  /**
+   * Focus to next paragraph.
+   *
+   * @param {RTETextBlock} block - The paragraph need to focus.
+   */
+  private focusToNextLine;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/action-handler-strategies/insert-function-block-strategy.d.ts

@@ -0,0 +1,27 @@
+import { InsertFunctionBlockAction } from '../actions/insert-function-block-action';
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle the insertion of a function block into the rich text editor.
+ */
+export declare class InsertFunctionBlockStrategy extends ActionHandleStrategy<InsertFunctionBlockAction, RTEBlock | VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertFunctionBlockAction, target: RTEBlock | VegaRTEContent): void;
+  /**
+   * Get a function block based on the specified type.
+   *
+   * @param {string} type - The type of function block to create.
+   * @returns {RTEFunctionBlock} The function block instance.
+   */
+  private getFunctionBlock;
+  /**
+   * We need to get the correct block if the current target is a function block element to avoid nesting function blocks.
+   *
+   * @param {RTEBlock | VegaRTEContent} currentTarget - The current target block or content.
+   * @returns {Nullable<RTEBlock>} The reference block.
+   */
+  private getReferenceBlock;
+}

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

@@ -0,0 +1,26 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { PastePlainTextAction } from '../actions/paste-plain-text-action';
+/**
+ * Strategy to handle the paste content into function block.
+ */
+export declare class PastePlainTextStrategy extends ActionHandleStrategy<PastePlainTextAction, RTEBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: PastePlainTextAction, target: RTEBlock): void;
+  /**
+   * Focus to next paragraph.
+   *
+   * @param {RTETextNode} node - The text node need to focus.
+   * @param {number} startOffset - The offset need to focus.
+   */
+  private focusToNextLine;
+  /**
+   * Copy link group annotations from copied block to target block.
+   *
+   * @param {BlockAnnotations} blockAnnotationMap - The target block annotation map.
+   * @param {BlockAnnotations} copiedAnnotationMap - The copied block annotation map.
+   */
+  private copyLinkGroupAnnotations;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/actions/insert-function-block-action.d.ts

@@ -0,0 +1,17 @@
+import { Nullable } from '../../../../../types/general';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare const INSERT_FUNCTION_BLOCK: string;
+export declare type RTEExtensionFunctionType = 'IF' | 'FOREACH';
+/**
+ * Action to insert a function block into the rich text editor.
+ *
+ * @example focusedBlock.apply(new InsertFunctionBlockAction('IF'))
+ * @example host.value.apply(new InsertFunctionBlockAction('IF'))
+ */
+export declare class InsertFunctionBlockAction extends ModifyContentAction {
+  type: string;
+  functionType: RTEExtensionFunctionType;
+  nextFocusNode: Nullable<RTENode>;
+  constructor(functionType: RTEExtensionFunctionType);
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/actions/paste-plain-text-action.d.ts

@@ -0,0 +1,17 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare const PASTE_PLAIN_TEXT: string;
+/**
+ * Action to paste plain text content into function block.
+ *
+ * @example functionBlock.apply(new PastePlainTextAction('content', range))
+ * @example host.value.apply(new PastePlainTextAction('content', range))
+ */
+export declare class PastePlainTextAction extends ModifyContentAction {
+  type: string;
+  blocksToBeInserted: RTEBlock[];
+  startNode: RTENode;
+  startOffset: number;
+  constructor(blocksToBeInserted: RTEBlock[], startNode: RTENode, startOffset: number);
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/function-block.d.ts

@@ -0,0 +1,58 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTELogicControlBlock } from '../dto/logic-control-block';
+export declare type VegaFunctionBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+};
+export declare type RTEFunctionBlockChild = RTELogicControlBlock | RTETextBlock;
+/**
+ * RTE Function Block
+ */
+export declare class RTEFunctionBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEFunctionBlockChild> {
+  type: string;
+  parent: VegaRTEContent | RTEHtmlBlock;
+  children: RTEFunctionBlockChild[];
+  constructor(id: string);
+  /**
+   * Creates an RTEFunctionBlock from a VegaFunctionBlock.
+   *
+   * @param {VegaFunctionBlock} block - The custom block to convert.
+   * @param {VegaRTETransformOptions} [options] - Optional transformation options.
+   * @returns {RTEFunctionBlock} The resulting RTEFunctionBlock.
+   */
+  static from(block: VegaFunctionBlock, options?: VegaRTETransformOptions): RTEFunctionBlock;
+  /**
+   * Converts the RTEFunctionBlock and its children to an HTML string.
+   *
+   * @returns {string} The HTML string representation of the function block.
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: VegaRTEContent | RTEHtmlBlock): RTEFunctionBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaFunctionBlock;
+  /**
+   * Get the style string for function content block, excluding default paragraph styles.
+   *
+   * @param {RTETextBlock} block - The text block to extract styles from
+   * @returns {string} - The style attribute string
+   */
+  private getFunctionContentStyle;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/logic-control-block.d.ts

@@ -0,0 +1,55 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTECustomBlock } from '../../../interface';
+import { RTEFunctionBlock } from '../dto/function-block';
+import { RTELogicControlNode } from '../dto/logic-control-node';
+export declare type VegaRTELogicControlBlock = VegaRTECustomBlock & {
+  statementText: string;
+};
+/**
+ * Class representing a logic control block in the rich text editor.
+ */
+export declare class RTELogicControlBlock extends RTEBlock {
+  type: string;
+  parent: RTEFunctionBlock;
+  children: RTELogicControlNode[];
+  statementText: string;
+  constructor(id: string, statementText: string, parent?: RTEFunctionBlock);
+  /**
+   * Create a logic control block from a JSON representation.
+   *
+   * @param {VegaRTELogicControlBlock} json - The JSON object representing the logic control block.
+   * @returns {RTELogicControlBlock} - The created logic control block.
+   */
+  static from(json: VegaRTELogicControlBlock): RTELogicControlBlock;
+  /**
+   * Check the block is not empty.
+   *
+   * @returns {boolean} - Always true for logic control block.
+   */
+  isNotEmpty(): boolean;
+  /**
+   * Get the last node of the block.
+   *
+   * @returns {RTELogicControlNode} - The last node in the block.
+   */
+  getLastNode(): RTELogicControlNode;
+  /**
+   * Convert the block to its HTML representation.
+   *
+   * @returns {string} - The HTML string of the logic control block.
+   */
+  toHtml(): string;
+  /**
+   * Clone the current block instance.
+   *
+   * @param { RTEFunctionBlock } parent - The parent function block for the cloned instance.
+   * @returns {RTELogicControlBlock} - A new instance of RTEStatementSyntaxBlock.
+   */
+  clone(parent: RTEFunctionBlock): RTELogicControlBlock;
+  /**
+   * Get the JSON representation of the block.
+   *
+   * @returns {VegaRTELogicControlBlock} - The JSON object of the logic control block.
+   */
+  toJSON(): VegaRTELogicControlBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/logic-control-node.d.ts

@@ -0,0 +1,48 @@
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { RTELogicControlBlock } from './logic-control-block';
+/**
+ * Class representing a logic control node in the rich text editor.
+ */
+export declare class RTELogicControlNode extends RTENode {
+  type: string;
+  text: string;
+  parent: RTELogicControlBlock;
+  constructor(id: string, text: string, parent: RTELogicControlBlock);
+  /**
+   * Clone the current node instance.
+   *
+   * @returns {RTELogicControlNode} - A new instance of RTELogicControlNode.
+   */
+  clone(): RTELogicControlNode;
+  /**
+   * Convert the node to its HTML representation.
+   *
+   * @returns {string} - The HTML string of the logic control node.
+   */
+  toHtml(): string;
+  /**
+   * Convert the node to a JSON representation.
+   *
+   * @returns {unknown} - The JSON object of the statement syntax node.
+   */
+  toJSON(): unknown;
+  /**
+   * Get the end offset of the node's range.
+   *
+   * @returns {number} - The end offset of the node's range.
+   */
+  getRangeEndOffset(): number;
+  /**
+   * Get the container element for the node's range.
+   *
+   * @returns {Nullable<Node>} - The container node for the range.
+   */
+  getRangeContainer(): Nullable<Node>;
+  /**
+   * Get the content editable state of the node.
+   *
+   * @returns {boolean} - The content editable state of the node.
+   */
+  isContentEditable(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-function-block-strategy.d.ts

@@ -0,0 +1,27 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { VegaRTECustomNode } from '../../../interface';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTEFunctionBlockChild } from '../dto/function-block';
+/**
+ * Strategy to convert a div with class 'statement' into an function block.
+ */
+export declare class DivToFunctionBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(): Nullable<RTEBlock | VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTEHtmlBlock, childBlocks: RTEFunctionBlockChild[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-function-content-strategy.d.ts

@@ -0,0 +1,14 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTETransformOptions } from '../../../interface';
+import { DivToLogicControlBlockStrategy } from './div-to-logic-control-block-strategy';
+/**
+ * Strategy to convert a div with class 'statementelement' into an function block.
+ */
+export declare class DivToFunctionContentStrategy extends DivToLogicControlBlockStrategy {
+  protected blockClassName: string;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/element-to-dto-strategies/div-to-logic-control-block-strategy.d.ts

@@ -0,0 +1,32 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockToRTEBlockStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+/**
+ * Strategy to convert a div with class 'statementsyntax' into an RTELogicControlBlock DTO.
+ */
+export declare class DivToLogicControlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  protected blockClassName: string;
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[]): Nullable<RTEBlock>;
+  /**
+   * The logic control block does not have child blocks to append. so this method is intentionally left empty.
+   */
+  appendChildBlocks(): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+  /**
+   * Checks if the given element is a child of a function block
+   *
+   * @param {HTMLElement} element - The HTML element to check
+   * @returns {boolean} True if the element is a child of a function block, false otherwise
+   */
+  private isFunctionBlockChild;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/function-extension.d.ts

@@ -0,0 +1,19 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTEExtensionContext } from '../../interface';
+/**
+ * Function extension class for Vega Rich Text Editor.
+ */
+export declare class VegaRTEFunctionExtension extends VegaRTEExtension {
+  private toolbarButtonRenderer;
+  constructor();
+  /**
+   * Initializes the extension with the given context
+   *
+   * @param {RTEExtensionContext} context - extension context
+   */
+  initialExtension(context: RTEExtensionContext): void;
+  /**
+   * Remove the appen children strategies to prevent default insert new paragraph logic in function block
+   */
+  private preventFunctionBlockDefaultInsertNewParagraph;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/renderers/function-block-renderer.d.ts

@@ -0,0 +1,25 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTEFunctionBlock } from '../dto/function-block';
+/**
+ * Renderer for Function Block
+ */
+export declare class RTEFunctionBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement: VegaRTECreateElementFunction, renderData: RTEFunctionBlock): VegaRTERenderResult;
+  /**
+   * Defines the function block styles to be injected into the RTE scope.
+   *
+   * @returns {string} - The styles as a string.
+   */
+  injectRTEScopeStyles(): string;
+  /**
+   * Gets the class name for the function block element.
+   *
+   * @param {RTEFunctionBlock} block - The function block.
+   * @returns {string} The class name for the function block element.
+   */
+  private getElementClassName;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/renderers/function-toolbar-button-renderer.d.ts

@@ -0,0 +1,33 @@
+import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult, RTEDropdownListItem, RTEExtensionContext } from '../../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+import { RTEExtensionFunctionType } from '../actions/insert-function-block-action';
+/**
+ * Function toolbar button renderer class.
+ */
+export declare class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  static FUNCTION_LIST: RTEDropdownListItem[];
+  private extensionContext?;
+  /**
+   * Injects the extension context
+   *
+   * @param {RTEExtensionContext} context - extension context
+   */
+  injectExtensionContext(context: RTEExtensionContext): void;
+  /**
+   * @inheritDoc
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Overrides the isDisabled method to determine if the button should be disabled.
+   *
+   * @returns {boolean} - true if the button should be disabled, false otherwise.
+   */
+  protected isDisabled(): boolean;
+  protected handleButtonClick(): void;
+  /**
+   * Handles dropdown click event
+   *
+   * @param {RTEExtensionFunctionType} itemKey - key of the clicked item
+   */
+  protected handleDropdownClick(itemKey: RTEExtensionFunctionType): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/functions/renderers/logic-control-block-renderer.d.ts

@@ -0,0 +1,12 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTELogicControlBlock } from '../dto/logic-control-block';
+/**
+ * Renders a logic control block in the rich text editor.
+ */
+export declare class RTELogicControlBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTELogicControlBlock): VegaRTERenderResult;
+}

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

@@ -1,4 +1,4 @@
-import { RTEDropdownListItem, RTEExtensionContext, RTELanguageExtensionState } from '../../interface';
+import { RTEDropdownListGroup, RTEDropdownListItem, RTEExtensionContext, RTELanguageExtensionState } from '../../interface';
 import { VegaRTEExtension } from '../extension.abstract';
 /**
  * Language extension for Vega Rich Text Editor.
@@ -7,7 +7,7 @@ import { VegaRTEExtension } from '../extension.abstract';
 export declare class VegaRTELanguageExtension extends VegaRTEExtension {
   private languageToolbarButtonRenderer;
   private languageState;
-  constructor(languageList: RTEDropdownListItem[], languagesState?: RTELanguageExtensionState);
+  constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languagesState?: RTELanguageExtensionState);
   /**
    * Initializes the language extension.
    * Applies the content for the selected language upon initialization.

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

@@ -1,4 +1,4 @@
-import { RTEDropdownListItem, VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { RTEDropdownListGroup, RTEDropdownListItem, VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
 import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
 export declare type LanguageSelectedCallback = (selectedLanguage: string) => void;
 /**
@@ -9,7 +9,7 @@ export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButt
   private selectedLanguage;
   private labelRef;
   private languageChangeCallback;
-  constructor(languageList: RTEDropdownListItem[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage: string);
+  constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage: string);
   /**
    * Public method to set the selected language.
    *

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

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

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

@@ -22,12 +22,11 @@ export declare class RTETokenNodeRenderer extends VegaRTEExtensionRenderer {
    */
   injectExtensionContext(context: RTEExtensionContext): void;
   /**
-   * Get the style for the token element.
+   * Override to inject RTE scope styles for the token node.
    *
-   * @param {RTETokenNode} node - The token node.
-   * @returns {Record<string, string>} The style object for the token element.
+   * @returns {string} The CSS styles for the token node.
    */
-  protected getStyle(node: RTETokenNode): Record<string, string>;
+  injectRTEScopeStyles(): string;
   /**
    * Handle the click event on the token element.
    *

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

@@ -282,7 +282,7 @@ export type VegaRTECustomElementAction = {
 
 export type VegaRTECustomBlock = VegaRTEBlockBase & {
 	type: string;
-	children: VegaRTECustomNode[];
+	children?: (VegaRTECustomNode | VegaRTECustomBlock)[];
 };
 
 export type VegaRTECustomNode = VegaRTEBaseNode & {
@@ -357,8 +357,14 @@ export type RTEToolbarButtonProps = {
 
 export type RTEDropdownListItem = { key: string; label: string; icon?: string };
 
+export type RTEDropdownListGroup = {
+	key: string;
+	label: string;
+	children: (RTEDropdownListItem | RTEDropdownListGroup)[];
+};
+
 export type RTEToolbarDropdownProps = {
-	source?: RTEDropdownListItem[];
+	source?: (RTEDropdownListItem | RTEDropdownListGroup)[];
 	selectType?: 'none' | 'single';
 	selectedSourceKey?: string;
 	maxHeight?: number;