@globalpayments/vega 2.66.0 → 2.68.0

package/dist/types/components/vega-rich-text-editor/dto/blocks/html-block.d.ts

@@ -1,15 +1,15 @@
 import { RTEBlock } from './block.abstract';
-import { VegaRTEHtmlBlock, VegaRTETransformOptions, RTEContentBlock } from '../../interface';
+import { VegaRTEHtmlBlock, VegaRTETransformOptions } from '../../interface';
 import { VegaRTEContent } from '../content-state';
 import { RTENode } from '../nodes/node.abstract';
 /**
  * HTML Block
  */
-export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEContentBlock> {
+export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEBlock> {
   type: 'html-block';
   parent: VegaRTEContent | RTEHtmlBlock;
   htmlTag: string;
-  children: RTEContentBlock[];
+  children: RTEBlock[];
   constructor(id: string, htmlTag: string);
   /**
    * Converts a VegaRTEHtmlBlock to an RTEHtmlBlock.

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

@@ -82,6 +82,12 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
    * @returns {RTETextBlockTagType} The HTML tag for the block.
    */
   getBlockTag(): RTETextBlockTagType;
+  /**
+   * Get the HTML string for the children nodes, including handling link group annotations.
+   *
+   * @returns {string} The HTML string representing the children nodes.
+   */
+  getChildrenHtml(): string;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/dto/nodes/node.abstract.d.ts

@@ -126,17 +126,6 @@ export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
    * @param {ModifyContentAction} action ModifyContentAction
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  /**
-   * Merge an array of annotation styles into a single style object.
-   * e.g.,
-   * { textDecoration: 'underline', textDecoration: 'line-through' }
-   * -> { textDecoration: 'underline line-through' }
-   *
-   * @param {AnnotationStyle[]} styles - Array of annotation style objects to merge.
-   * @param {string[]} canMergeKeyList - List of style keys that can be merged by concatenation.
-   * @returns {AnnotationStyle} - The merged annotation style object.
-   */
-  private mergeAnnotationStyles;
   /**
    * Clone the node.
    *

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

@@ -1,3 +1,5 @@
+import { BaseRenderer } from '../../../helpers/rte-manager/dto-renderer-manager';
+import { Nullable } from '../../../types/general';
 import { RTEBlock } from '../dto/blocks/block.abstract';
 import { RTENode } from '../dto/nodes/node.abstract';
 import { VegaRTEBaseRenderer } from '../dto/renderers/base-renderer';
@@ -8,6 +10,13 @@ declare type VegaRTEUseRef = (element: HTMLElement) => void;
  */
 export declare abstract class VegaRTEExtensionRenderer extends VegaRTEBaseRenderer<RTEBlock | RTENode, VegaRTERenderResult> {
   static REGISTER_REF_FLAG: string;
+  /**
+   * Returns the styles to be injected into the RTE scope.
+   * Override this method to provide custom styles for the custom blocks or nodes.
+   *
+   * @returns {string} - The styles as a string.
+   */
+  injectRTEScopeStyles(): string;
   /**
    * Renders the given data as a DOM element.
    *
@@ -24,6 +33,13 @@ export declare abstract class VegaRTEExtensionRenderer extends VegaRTEBaseRender
    * @returns {VegaRTEUseRef} - The function to register the element.
    */
   protected useRef(renderData: RTEBlock | RTENode): VegaRTEUseRef;
+  /**
+   * Get a registered renderer by its key.
+   *
+   * @param {string} key - The key of the renderer.
+   * @returns {Nullable<BaseRenderer>} - The registered renderer or null if not found.
+   */
+  protected getDTORenderer(key: string): Nullable<BaseRenderer>;
   /**
    * Auto render the block children if the block element is not exist
    *

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

@@ -1,5 +1,5 @@
 import { Nullable } from '../../../types/general';
-import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult, RTEToolbarDropdownProps, RTEDropdownListItem, RTEToolbarButtonProps } from '../interface';
+import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult, RTEToolbarDropdownProps, RTEDropdownListItem, RTEToolbarButtonProps, RTEDropdownListGroup } from '../interface';
 /**
  * Base class for rendering extension toolbar button in the rich text editor.
  * The renderer provides common functionalities for rendering toolbar buttons, including:
@@ -40,10 +40,10 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * Renders the dropdown list template.
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
-   * @param {RTEDropdownListItem[]} itemList - The list of dropdown items.
+   * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList - The list of dropdown items.
    * @returns {VegaRTERenderResult} - The render result for the dropdown list.
    */
-  protected renderDropdownListTemplate(h: VegaRTECreateElementFunction, itemList: RTEDropdownListItem[]): VegaRTERenderResult;
+  protected renderDropdownListTemplate(h: VegaRTECreateElementFunction, itemList: (RTEDropdownListItem | RTEDropdownListGroup)[]): VegaRTERenderResult;
   /**
    * Renders a dropdown item for the toolbar button.
    *
@@ -52,6 +52,14 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * @returns {VegaRTERenderResult} - The render result for the dropdown item.
    */
   protected renderDropdownItem(h: VegaRTECreateElementFunction, item: RTEDropdownListItem): VegaRTERenderResult;
+  /**
+   * Renders a dropdown item for the toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {RTEDropdownListGroup} item - The dropdown group.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown item.
+   */
+  protected renderDropdownGroup(h: VegaRTECreateElementFunction, item: RTEDropdownListGroup): VegaRTERenderResult;
   /**
    * Renders a common toolbar button with optional icon, label, and arrow icon.
    *
@@ -90,6 +98,14 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * @param {MouseEvent} e The mouse event to prevent default action for.
    */
   protected preventDefault(e: MouseEvent): void;
+  /**
+   * Recursively searches for a dropdown list item by its key.
+   *
+   * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList The list of dropdown items or groups to search through.
+   * @param {string} key The key of the item to find.
+   * @returns {Nullable<RTEDropdownListItem>} The dropdown list item if found, otherwise null.
+   */
+  protected getListItemByKey(itemList: (RTEDropdownListItem | RTEDropdownListGroup)[], key: string): Nullable<RTEDropdownListItem>;
   /**
    * Handles the button click event.
    *

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