@heartlandone/vega 2.73.0 → 2.74.0-RTE-table-preview

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

@@ -0,0 +1,79 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBodyBlock, VegaRTETableBodyBlock } from './table-body-block';
+import { RTETableHeadBlock, VegaRTETableHeadBlock } from './table-head-block';
+import { VegaRTETableAnnotation } from '../annotations/table-annotation';
+import { RTETableCaptionBlock, VegaRTETableCaptionBlock } from './table-caption-block';
+import { Nullable } from '../../../../../types/general';
+export declare type VegaRTETableBlock = VegaRTEBlockBase & {
+  type: string;
+  /**
+   * Children of the table block. May include an optional `table-caption` block
+   * alongside structural blocks like `table-head` and `table-body`.
+   */
+  children: (VegaRTETableHeadBlock | VegaRTETableBodyBlock | VegaRTETableCaptionBlock)[];
+  annotations?: VegaRTEBlockAnnotations & {
+    table?: VegaRTETableAnnotation;
+  };
+};
+export declare type VegaRTETableChildType = RTETableHeadBlock | RTETableBodyBlock | RTETableCaptionBlock;
+/**
+ * Class representing a table block in the rich text editor.
+ */
+export declare class RTETableBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, VegaRTETableChildType> {
+  type: string;
+  parent: VegaRTEContent | RTEHtmlBlock;
+  children: VegaRTETableChildType[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableBlock, options?: VegaRTETransformOptions): RTETableBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: VegaRTEContent | RTEHtmlBlock): RTETableBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * Get the first node of the table block.
+   *
+   * @returns {RTENode} The first node of the table block.
+   */
+  getFirstNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableBlock;
+  /**
+   * Retrieves the caption block from the children collection, if present.
+   *
+   * @returns {Nullable<RTETableCaptionBlock>} The caption block or `null`.
+   */
+  getCaption(): Nullable<RTETableCaptionBlock>;
+  /**
+   * Inserts, replaces, or removes the caption block within the children.
+   *
+   * @param {Nullable<RTETableCaptionBlock>} caption - The caption block to set, or `null` to remove.
+   */
+  setCaption(caption: Nullable<RTETableCaptionBlock>): void;
+  /**
+   * Checks whether the table currently stores a caption block reference.
+   *
+   * @returns {boolean} `true` when a caption DTO is attached; otherwise `false`.
+   */
+  hasCaption(): boolean;
+}

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

@@ -0,0 +1,42 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTETableRowBlock, VegaRTETableRowBlock } from './table-row-block';
+export declare type VegaRTETableBodyBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTETableRowBlock[];
+};
+/**
+ * Class representing a table body block in the rich text editor.
+ */
+export declare class RTETableBodyBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTETableRowBlock[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableBodyBlock, options?: VegaRTETransformOptions): RTETableBodyBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableBodyBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableBodyBlock;
+}

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

@@ -0,0 +1,41 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEBlockBase, VegaRTETextBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare type VegaRTETableCaptionBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTETextBlock[];
+};
+/**
+ * Represents the optional caption block for a table.
+ */
+export declare class RTETableCaptionBlock extends RTEBlock<RTETableBlock, RTEBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableCaptionBlock, options?: VegaRTETransformOptions): RTETableCaptionBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableCaptionBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableCaptionBlock;
+}

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

@@ -0,0 +1,45 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableRowBlock } from './table-row-block';
+import { VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+export declare type VegaRTETableCellBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+  annotations?: VegaRTEBlockAnnotations & {
+    tableCell?: VegaRTETableCellAnnotation;
+  };
+};
+/**
+ * Class representing a table cell block in the rich text editor.
+ */
+export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlock> {
+  type: string;
+  parent: RTETableRowBlock;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableCellBlock, options?: VegaRTETransformOptions): RTETableCellBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableRowBlock): RTETableCellBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableCellBlock;
+}

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

@@ -0,0 +1,42 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTETableRowBlock } from './table-row-block';
+export declare type VegaRTETableHeadBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTETableRowBlock[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadBlock, options?: VegaRTETransformOptions): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-cell-block.d.ts

@@ -0,0 +1,34 @@
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableRowBlock } from './table-row-block';
+import { RTETableCellBlock } from './table-cell-block';
+import { VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+export declare type VegaRTETableHeadCellBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+  annotations?: VegaRTEBlockAnnotations & {
+    tableCell?: VegaRTETableCellAnnotation;
+  };
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadCellBlock extends RTETableCellBlock {
+  type: string;
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadCellBlock, options?: VegaRTETransformOptions): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableRowBlock): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadCellBlock;
+}

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

@@ -0,0 +1,44 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBodyBlock } from './table-body-block';
+import { RTETableHeadBlock } from './table-head-block';
+import { RTETableCellBlock, VegaRTETableCellBlock } from './table-cell-block';
+import { RTETableHeadCellBlock, VegaRTETableHeadCellBlock } from './table-head-cell-block';
+export declare type VegaRTETableRowBlock = VegaRTEBlockBase & {
+  type: string;
+  children: (VegaRTETableCellBlock | VegaRTETableHeadCellBlock)[];
+};
+/**
+ * Class representing a table row block in the rich text editor.
+ */
+export declare class RTETableRowBlock extends RTEBlock<RTETableBodyBlock | RTETableHeadBlock, RTETableCellBlock | RTETableHeadCellBlock> {
+  type: string;
+  parent: RTETableBodyBlock | RTETableHeadBlock;
+  children: (RTETableCellBlock | RTETableHeadCellBlock)[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableRowBlock, options?: VegaRTETransformOptions): RTETableRowBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBodyBlock | RTETableHeadBlock): RTETableRowBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableRowBlock;
+}

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

@@ -0,0 +1,29 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTETableCaptionBlock } from '../dto/table-caption-block';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML table caption container element into an RTETableCaptionBlock DTO.
+ *
+ * This expects to be applied to the rendered caption container that wraps the actual caption content
+ * (for example, the `div.v-rte--extension-table-caption` element that Stencil renders for table captions).
+ */
+export declare class CaptionToCaptionBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableCaptionBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

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

@@ -0,0 +1,26 @@
+import { Nullable } from '../../../../../types/general';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTECustomNode, VegaRTETransformOptions } from '../../../interface';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy to convert a native HTML table element into an RTETableBlock DTO.
+ */
+export declare class TableToTableBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock | VegaRTECustomNode>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/tbody-to-table-body-block-strategy.d.ts

@@ -0,0 +1,26 @@
+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';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML tbody element into an RTETableBodyBlock DTO.
+ */
+export declare class TbodyToTableBodyBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableBodyBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/td-to-table-cell-block-strategy.d.ts

@@ -0,0 +1,27 @@
+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';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert native HTML td/th element into table cell DTOs.
+ */
+export declare class TdToTableCellBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableCellBlock | RTETableHeadCellBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/thead-to-table-head-block-strategy.d.ts

@@ -0,0 +1,26 @@
+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';
+import { RTETableHeadBlock } from '../dto/table-head-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML thead element into an RTETableHeadBlock DTO.
+ */
+export declare class TheadToTableHeadBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableHeadBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/element-to-dto-strategies/tr-to-table-row-block-strategy.d.ts

@@ -0,0 +1,26 @@
+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';
+import { RTETableRowBlock } from '../dto/table-row-block';
+import { VegaRTETransformOptions } from '../../../interface';
+/**
+ * Strategy to convert a native HTML tr element into an RTETableRowBlock DTO.
+ */
+export declare class TrToTableRowBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * @inheritDoc
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * @inheritDoc
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(currentBlock: RTETableRowBlock, childBlocks: RTEBlock[]): void;
+  /**
+   * @inheritDoc
+   */
+  shouldProceedToElementChildren(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-body-renderer.d.ts

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

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-caption-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCaptionBlock } from '../dto/table-caption-block';
+export declare const TABLE_CAPTION_PLACEHOLDER_TEXT: string;
+/**
+ * Renderer for the optional table caption node.
+ */
+export declare class RTETableCaptionRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCaptionBlock): VegaRTERenderResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-cell-renderer.d.ts

@@ -0,0 +1,37 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableExtensionContext } from '../table-extension';
+/**
+ * Renders a table cell block in the rich text editor.
+ */
+export declare class RTETableCellRenderer extends VegaRTEExtensionRenderer {
+  private extensionContext;
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Injects the extension context
+   *
+   * @param {RTETableExtensionContext} context - extension context
+   */
+  injectExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Renders the table cell based on its type (td or th).
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @param {RTERenderContext} rteContext - The rte editor context.
+   * @param {'td' | 'th'} elementType - The type of table cell element ('td' or 'th').
+   * @returns {VegaRTERenderResult} - The rendered table cell element.
+   */
+  protected renderByCellType(h: VegaRTECreateElementFunction, renderData: RTETableCellBlock, rteContext: RTERenderContext, elementType: 'td' | 'th'): VegaRTERenderResult;
+  /**
+   * Returns the mouse event listeners for selection handling.
+   *
+   * @param {RTETableCellBlock} renderData - The table cell block to render.
+   * @returns {RTETableSelectionListenersType} - The mouse event listeners.
+   */
+  private onSelectionListeners;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -0,0 +1,88 @@
+import { RTETableColorSchema, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import type { RTETableExtensionContext } from '../table-extension';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Renderer for a generic, dynamically positioned popover used within table-related extensions.
+ *
+ * - The popover target is based on the current cursor/selection position.
+ * - The popover content is rendered dynamic content.
+ */
+export declare class TableDynamicPopoverRenderer {
+  private popoverRef;
+  private getTableRef;
+  private selectionAnchorRef;
+  private extensionContext;
+  private tableColorSchema;
+  private currentTableBlock;
+  private currentFocusNode;
+  private tablePropertiesFormRef;
+  private cellPropertiesFormRef;
+  private popoverCloseType;
+  private tablePropertiesHandlerMap;
+  private cellPropertiesHandlerMap;
+  constructor(colors: RTETableColorSchema[]);
+  /**
+   * removes the multi-cell selection anchor element from the DOM, if present,
+   * and clears the internal reference.
+   */
+  destroy(): void;
+  /**
+   * Shows the popover. Before showing, it will refresh the target so
+   * that the popover is positioned relative to the latest cursor position.
+   *
+   * @param {string} type - The table setting type determining which
+   *  content variant to display (for example, table properties or cell properties).
+   */
+  show(type: string): Promise<void>;
+  /**
+   * hide the popover.
+   */
+  hide(): Promise<void>;
+  /**
+   * Injects the RTE extension context.
+   *
+   * @param {RTETableExtensionContext} context - The RTE extension context.
+   */
+  injectRTEExtensionContext(context: RTETableExtensionContext): void;
+  /**
+   * Renders a vega-popover whose target and content are provided dynamically by callers.
+   *
+   * @param {VegaRTECreateElementFunction} h - The create element function.
+   * @param {() => HTMLElement} getTableRef - Current table DOM reference
+   * @param {RTETableBlock} renderData - Current table block being rendered.
+   * @returns {VegaRTERenderResult} The rendered popover host.
+   */
+  render(h: VegaRTECreateElementFunction, getTableRef: () => Nullable<HTMLElement>, renderData: RTETableBlock): VegaRTERenderResult;
+  /**
+   * Updates the visibility of the pre-rendered content blocks based on type.
+   *
+   * @param {string} type - The table setting type determining which content variant should be visible.
+   */
+  private updateContent;
+  /**
+   * Updates the table properties based on the emitted event.
+   *
+   * @param {CustomEvent} e - The custom event containing the update details.
+   */
+  private handleTablePropertiesUpdate;
+  /**
+   * Stores the current focus node before properties update action.
+   */
+  private storeCurrentFocusNode;
+  /**
+   * Create and position an invisible anchor element whose position and size are identical to the geometry of the current multi-cell selection.
+   * This anchor element will then be used as the target of the popup, so that the popup appears near the entire selection area.
+   *
+   * @param {RTETableCellBlock[]} cells - The currently selected table cells.
+   * @param {Nullable<HTMLElement>} tableRef - The container table element.
+   * @returns {Nullable<HTMLElement>} The positioned anchor element.
+   */
+  private getOrCreateSelectionAnchor;
+  /**
+   * Updates the cell properties based on the emitted event.
+   *
+   * @param {CustomEvent} e - The custom event containing the update details.
+   */
+  private handleCellPropertiesUpdate;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-head-cell-renderer.d.ts

@@ -0,0 +1,12 @@
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTETableCellRenderer } from './table-cell-renderer';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Renders a head cell block in the rich text editor.
+ */
+export declare class RTETableHeadCellRenderer extends RTETableCellRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(h: VegaRTECreateElementFunction, renderData: RTETableHeadCellBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+}