@heartlandone/vega 2.71.0 → 2.72.0-RTE-table-preview

package/dist/types/components/vega-progress-tracker/slimmers/controllers/vega-progress-tracker-current-steps-controller.d.ts

@@ -0,0 +1,39 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-observer/mutation-observer-slimmer';
+import { VegaProgressTracker } from '../../vega-progress-tracker';
+/**
+ * Controls the current steps of the progress tracker component.
+ */
+export declare class VegaProgressTrackerCurrentStepsController extends VegaSlimmer {
+  host: VegaProgressTracker['host'];
+  steps: VegaProgressTracker['steps'];
+  currentSteps: VegaProgressTracker['currentSteps'];
+  renderModeController: VegaProgressTracker['renderModeController'];
+  current: VegaProgressTracker['current'];
+  deprecatedPropertySlimmer: VegaProgressTracker['deprecatedPropertySlimmer'];
+  protected mutationObserver: MutationObserverSlimmer;
+  /** connectedCallback */
+  connectedCallback(): void;
+  /** disconnectedCallback */
+  disconnectedCallback(): void;
+  /** componentWillLoad */
+  componentWillLoad(): void;
+  /** componentDidLoad */
+  componentDidLoad(): void;
+  /** while steps changed, we need sync up current steps */
+  watchSteps(): void;
+  /** while current state changed, we need sync up current steps */
+  watchCurrentChange(): void;
+  /** while completedStepArray changed, we need sync up current steps */
+  watchCompletedStepArray(): void;
+  /** while completedSteps changed, we need sync up current steps */
+  watchCompletedSteps(): void;
+  /**
+   * Sync up current steps
+   */
+  private syncUpCurrentSteps;
+  /**
+   * If template mode, append slot attribute to each step element in host.
+   */
+  private appendSlotAttribute;
+}

package/dist/types/components/vega-progress-tracker/slimmers/controllers/vega-progress-tracker-render-mode-controller.d.ts

@@ -0,0 +1,21 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaProgressTracker } from '../../vega-progress-tracker';
+/**
+ * Controls the render mode of the progress tracker component.
+ */
+export declare class VegaProgressTrackerRenderModeController extends VegaSlimmer {
+  host: VegaProgressTracker['host'];
+  private renderMode;
+  /** connectedCallback */
+  connectedCallback(): void;
+  /**
+   * Checks if the render mode is set to 'SOURCE'.
+   *
+   * @returns { boolean }A boolean value indicating whether the render mode is set to 'SOURCE'.
+   */
+  isSourceRenderMode(): boolean;
+  /**
+   * The function sets the render mode based on the presence of a specific element in the host component.
+   */
+  private setRenderMode;
+}

package/dist/types/components/vega-progress-tracker/slimmers/renderers/vega-progress-tracker-renderer.d.ts

@@ -0,0 +1,21 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaProgressTracker } from '../../vega-progress-tracker';
+/** Renders the progress tracker component. */
+export declare class VegaProgressTrackerRenderer extends VegaSlimmer {
+  host: VegaProgressTracker['host'];
+  currentSteps: VegaProgressTracker['currentSteps'];
+  canClickStep: VegaProgressTracker['canClickStep'];
+  current: VegaProgressTracker['current'];
+  deprecatedPropertySlimmer: VegaProgressTracker['deprecatedPropertySlimmer'];
+  currentStepController: VegaProgressTracker['currentStepController'];
+  currentDirection: VegaProgressTracker['currentDirection'];
+  renderModeController: VegaProgressTracker['renderModeController'];
+  private carouselContainerRef;
+  private carouselRef;
+  gotoCarouselPage(): Promise<void>;
+  render(): HTMLElement;
+  private renderStepIcon;
+  private renderStep;
+  private renderStepTitle;
+  private onStepIconClick;
+}

package/dist/types/components/vega-progress-tracker/type.d.ts

@@ -0,0 +1 @@
+export type VegaProgressTrackerDirectionType = 'vertical' | 'horizontal' | 'horizontal-compact';

package/dist/types/components/vega-progress-tracker/vega-progress-tracker-step/slimmers/controllers/vega-progress-tracker-step-state-controller.d.ts

@@ -0,0 +1,12 @@
+import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-state/sub-state-observer-slimmer';
+import { VegaProgressTrackerStep } from '../../vega-progress-tracker-step';
+/**
+ * Controls the state of a progress tracker step component.
+ */
+export declare class VegaProgressTrackerStepStateController extends SubStateObserverSlimmer<HTMLVegaProgressTrackerStepElement> {
+  host: VegaProgressTrackerStep['host'];
+  progressStatus: VegaProgressTrackerStep['progressStatus'];
+  isCurrent: VegaProgressTrackerStep['isCurrent'];
+  stepKey: VegaProgressTrackerStep['stepKey'];
+  constructor();
+}

package/dist/types/components/vega-progress-tracker/vega-progress-tracker-step/vega-progress-tracker-step.d.ts

@@ -0,0 +1,22 @@
+import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaProgressTrackerStepStateController } from './slimmers/controllers/vega-progress-tracker-step-state-controller';
+import { ProgressStepStatus } from '../slimmers/controllers/dto/internal-progress-tracker-step';
+/**
+ * @vegaVersion 2.72.0-RTE-table-preview
+ */
+export declare class VegaProgressTrackerStep {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected readonly stateController: VegaProgressTrackerStepStateController;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaDropdownItemElement>;
+  host: HTMLVegaProgressTrackerStepElement;
+  progressStatus: ProgressStepStatus;
+  isCurrent: boolean;
+  /**
+   * The unique key for the step.
+   *
+   * @vegaVersion 2.72.0-RTE-table-preview
+   */
+  stepKey: string;
+  render(): VegaProgressTrackerStep;
+}

package/dist/types/components/vega-progress-tracker/vega-progress-tracker.d.ts

@@ -3,16 +3,33 @@ import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { DeprecatedPropertySlimmerBase } from '../../helpers/slimmers/deprecated-property-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaProgressTrackerRenderer } from './slimmers/renderers/vega-progress-tracker-renderer';
+import { VegaProgressTrackerCurrentStepController } from './slimmers/controllers/vega-progress-tracker-current-step-controller';
+import { ResponsiveType } from '../../types/ui.type';
+import { VegaProgressTrackerDirectionType } from './type';
+import { InternalProgressTrackerStep } from './slimmers/controllers/dto/internal-progress-tracker-step';
+import { SubStateNotifySlimmerBase } from '../../helpers/slimmers/sub-state/sub-state-notify-slimmer-base';
+import { VegaProgressTrackerCurrentStepsController } from './slimmers/controllers/vega-progress-tracker-current-steps-controller';
+import { VegaProgressTrackerRenderModeController } from './slimmers/controllers/vega-progress-tracker-render-mode-controller';
+import { VegaProgressTrackerCurrentDirectionController } from './slimmers/controllers/vega-progress-tracker-current-direction-controller';
 /**
  * @vegaVersion 1.0.7
  */
 export declare class VegaProgressTracker {
   protected readonly globalSlimmers: GlobalSlimmers;
+  protected renderModeController: VegaProgressTrackerRenderModeController;
+  protected currentStepsController: VegaProgressTrackerCurrentStepsController;
+  protected currentStepController: VegaProgressTrackerCurrentStepController;
+  protected currentDirectionController: VegaProgressTrackerCurrentDirectionController;
+  protected renderer: VegaProgressTrackerRenderer;
   protected currentStepUpdateEventEmitter: EventEmitSlimmerBase;
+  protected currentStepsSubStateSlimmer: SubStateNotifySlimmerBase;
   protected readonly deprecatedPropertySlimmer: DeprecatedPropertySlimmerBase<string[]>;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaProgressTrackerElement>;
-  private carouselDom;
   host: HTMLVegaProgressTrackerElement;
+  currentSteps: InternalProgressTrackerStep[];
+  watchCurrentSteps(): void;
+  currentDirection: VegaProgressTrackerDirectionType;
   /**
    * Indicates the current step or stage in a
    *    sequential process or workflow,
@@ -25,7 +42,7 @@ export declare class VegaProgressTracker {
    * The below method is e2e-test covered in
    * @see{module:vega-progress-tracker-e2e-change-current-mobile}
    */
-  watchCurrentChange(newCurrent: number): Promise<void>;
+  watchCurrentChange(): Promise<void>;
   /**
    * Specifies the direction of the Progress Tracker component.
    *
@@ -33,10 +50,12 @@ export declare class VegaProgressTracker {
    *    In the horizontal direction, the tracker is divided into
    *    panes with navigable arrows. In the vertical direction,
    *    it is displayed as a single pane.
+   * It also can be set as ResponsiveType for responsive direction.
    *
    * @vegaVersion 1.0.7
    */
-  direction: 'vertical' | 'horizontal';
+  direction: ResponsiveType<VegaProgressTrackerDirectionType>;
+  watchDirection(): Promise<void>;
   /**
    * Specifies an array of step subtitles for
    *    the Progress Tracker component.
@@ -60,6 +79,7 @@ export declare class VegaProgressTracker {
    * @vegaVersion 1.5.0
    */
   completedStepArray: string[];
+  watchCompletedStepArray(): void;
   /**
    * Specifies an array of titles representing completed steps in the progress tracker,
    *    indicating successful completion within the workflow or process.
@@ -67,6 +87,7 @@ export declare class VegaProgressTracker {
    * @vegaVersion 2.2.0
    */
   completedSteps: string[];
+  watchCompletedSteps(): void;
   /**
    * Enables the ability to click on the steps in
    *    the Progress Tracker component.
@@ -87,7 +108,6 @@ export declare class VegaProgressTracker {
    * @vegaVersion 2.0.0
    */
   currentStepUpdate: EventEmitter<string>;
-  componentDidLoad(): void;
   /**
    * Invoke this method to change the tracker's current step
    *    to the next step, if available.
@@ -115,10 +135,4 @@ export declare class VegaProgressTracker {
    */
   getCurrent(): Promise<number>;
   render(): VegaProgressTracker;
-  private getStepState;
-  private onStepIconClick;
-  private renderStepIcon;
-  private renderSteps;
-  private updateCurrent;
-  private isElementVisible;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/annotation.abstract.d.ts

@@ -1,6 +1,3 @@
-import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { BlockAnnotationTypeEnum } from './block-annotation.abstract';
-import { CommonAnnotationTypeEnum } from './common-annotation.abstract';
 export declare enum InternalAnnotationTypeEnum {
   SELECTION_RANGE = "SELECTION_RANGE",
   CLEAR_FORMATTING = "CLEAR_FORMATTING",
@@ -9,6 +6,6 @@ export declare enum InternalAnnotationTypeEnum {
 /**
  * Abstract class for all annotations
  */
-export declare abstract class Annotation {
-  abstract readonly type: BlockAnnotationTypeEnum | NodeAnnotationTypeEnum | InternalAnnotationTypeEnum | CommonAnnotationTypeEnum;
+export declare abstract class Annotation<T = string> {
+  abstract readonly type: T;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/block-annotation.abstract.d.ts

@@ -11,8 +11,8 @@ export declare enum BlockAnnotationTypeEnum {
 /**
  * BlockAnnotation is an abstract class that represents a block annotation.
  */
-export declare abstract class BlockAnnotation extends Annotation {
-  abstract readonly type: BlockAnnotationTypeEnum;
+export declare abstract class BlockAnnotation<T = BlockAnnotationTypeEnum> extends Annotation<T> {
+  abstract readonly type: T;
   /**
    * Generate the style for the annotation.
    *
@@ -33,5 +33,5 @@ export declare abstract class BlockAnnotation extends Annotation {
    * @returns {Nullable<Record<string, unknown>>} JSON item of the annotation
    */
   abstract toJSON(): Nullable<Record<string, unknown>>;
-  abstract clone(): BlockAnnotation;
+  abstract clone(): BlockAnnotation<T>;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-annotation.d.ts

@@ -1,6 +1,13 @@
 import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
 import { AnnotationStyle, RTERenderContext, VegaRTETextStyleType } from '../../interface';
 import { Nullable } from '../../../../types/general';
+export declare type RTETextStyleBaseType = {
+  fontFamily: string;
+  fontWeight: string;
+  fontSize: string;
+  lineHeight: string;
+  minHeight: string;
+};
 /**
  * Text style annotation
  */

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

@@ -1,16 +1,14 @@
 import { AnnotationStyle, RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../interface';
-import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { Nullable } from '../../../../types/general';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import type { VegaRTEContent } from '../content-state';
-import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
-import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
+import { Annotation } from '../annotations/annotation.abstract';
 import type { RTENode } from '../nodes/node.abstract';
 import type { RTEListItemBlock } from './list-item-block';
 import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
 import { ClassType } from '../../../../types/class.type';
-export declare type BlockAnnotations = Map<RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue>;
+export declare type BlockAnnotations = Map<string, Annotation>;
 export declare type BlockAnnotationsEntity = [RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue];
 export declare type RTEBlockParentType = VegaRTEContent | RTEBlock;
 export declare type RTEBlockChildrenType = RTEBlock | RTENode;
@@ -76,16 +74,22 @@ export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChild
    * Get annotation by type
    *
    * @typedef T generic type
-   * @param {keyof typeof BlockAnnotationTypeEnum} type - Annotation type
+   * @param {string} type - Annotation type
    * @returns {Nullable<T>} - Annotation
    */
-  getAnnotationByType<T extends BlockAnnotation | LinkGroupAnnotation>(type: keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP): Nullable<T>;
+  getAnnotationByType<T extends Annotation>(type: string): Nullable<T>;
   /**
    * Apply action to block
    *
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Get the first node of the block
+   *
+   * @returns {Nullable<RTENode>} The first RTENode or null if no children exist.
+   */
+  getFirstNode(): Nullable<RTENode>;
   /**
    * Check if the block is a list item block
    *

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

@@ -41,6 +41,11 @@ export declare abstract class VegaRTEExtension {
    * @param {RTEExtensionContext} context - The context of the RTE extension.
    */
   initialExtension(context: RTEExtensionContext): void;
+  /**
+   * Callback method invoked when the extension is destroyed.
+   * Override this method to perform any necessary cleanup.
+   */
+  destroyExtension(): void;
   /**
    * Collect custom styles for the extension renderers.
    * If custom nodes have special styles, override this method to provide the styles.

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-cell-children-remove-interceptor.d.ts

@@ -0,0 +1,25 @@
+import { ActionHandlerExecution, ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import type { RTETableCellBlock } from '../dto/table-cell-block';
+import type { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Interceptor to prevent removal of all children from a cell, ensuring at least one child remains.
+ */
+export declare class PreventCellChildrenRemoveInterceptor extends ActionHandlerInterceptor<RemoveChildrenAction, RTETableCellBlock | RTETableHeadCellBlock> {
+  /**
+   * Prevent removal if the target cell would be left empty after the action.
+   *
+   * @param {RemoveChildrenAction} action - the action to be intercepted
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} target - the target cell block
+   * @returns {boolean} - true if the removal should be intercepted, false otherwise
+   */
+  canIntercept(action: RemoveChildrenAction, target: RTETableCellBlock | RTETableHeadCellBlock): boolean;
+  /**
+   * Add a new empty text node to the cell to prevent it from removal.
+   *
+   * @param {ActionHandlerExecution} _execution - the original execution function
+   * @param {RemoveChildrenAction} action - the action to be intercepted
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} target - the target cell block
+   */
+  intercept(_execution: ActionHandlerExecution, action: RemoveChildrenAction, target: RTETableCellBlock | RTETableHeadCellBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-cell-content-delete-interceptor.d.ts

@@ -0,0 +1,20 @@
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+import { DeleteBlockContentAction } from '../../../dto/actions/delete-block-content-action';
+import type { RTETextBlock } from '../../../dto/blocks/text-block';
+/**
+ * Interceptor to prevent deletion of a table cell if it is the cell with empty content.
+ */
+export declare class PreventCellContentDeleteInterceptor extends ActionHandlerInterceptor<DeleteBlockContentAction, RTETextBlock> {
+  /**
+   * Prevent deletion if the target block is the only child of a table cell and is empty.
+   *
+   * @param {DeleteBlockContentAction} _action - the action to be intercepted
+   * @param {RTETextBlock} target - the target block
+   * @returns {boolean} - true if the deletion should be intercepted, false otherwise
+   */
+  canIntercept(_action: DeleteBlockContentAction, target: RTETextBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-interceptors/prevent-row-insert-interceptor.d.ts

@@ -0,0 +1,19 @@
+import type { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import type { RTETableRowBlock } from '../dto/table-row-block';
+import { ActionHandlerInterceptor } from '../../../dto/action-handle-strategies/action-handle-interceptor.abstract';
+/**
+ * Interceptor to prevent insertion of non-cell blocks into a table row.
+ */
+export declare class PreventRowInsertInterceptor extends ActionHandlerInterceptor<InsertChildrenBeforeAction, RTETableRowBlock> {
+  /**
+   * Prevent insertion if any of the children to be inserted is not a table cell block.
+   *
+   * @param {InsertChildrenBeforeAction} action - the action to be intercepted
+   * @returns {boolean} - true if the insertion should be intercepted, false otherwise
+   */
+  canIntercept(action: InsertChildrenBeforeAction): boolean;
+  /**
+   * @inheritDoc
+   */
+  intercept(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/delete-table-block-strategy.d.ts

@@ -0,0 +1,14 @@
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import type { DeleteTableBlockAction } from '../actions/delete-table-block-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle the deletion of a table block from the parent.
+ */
+export declare class DeleteTableBlockStrategy extends ActionHandleStrategy<DeleteTableBlockAction, RTEBlock> {
+  /**
+   * Deletes the specified table block and updates the cursor position.
+   *
+   * @param {DeleteTableBlockAction} action - The action containing the table block to delete.
+   */
+  protected handleAction(action: DeleteTableBlockAction): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/delete-table-column-strategy.d.ts

@@ -0,0 +1,31 @@
+import { DeleteTableColumnAction } from '../actions/delete-table-column-action';
+import { RTETableBlock } from '../dto/table-block';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the deletion of table column from the parent.
+ */
+export declare class DeleteTableColumnStrategy extends TableColumnStrategy<DeleteTableColumnAction> {
+  /**
+   * Deletes the specified table column and updates the cursor position.
+   *
+   * @param {DeleteTableColumnAction} action - The action containing the table column to delete.
+   * @param {RTETableBlock} target - The target table block from which the column will be deleted.
+   */
+  protected handleAction(action: DeleteTableColumnAction, target: RTETableBlock): void;
+  /**
+   * Find the next focusable cell either after the deleted range or before it.
+   *
+   * @param {RTETableCellBlock[]} tableCellBlockDeleteRange - The range of table cell blocks to be deleted.
+   * @param {number[]} indexRange - The start and end indices of the cells to be deleted.
+   * @returns {Nullable<RTETableCellBlock | RTETableHeadCellBlock>} The next focusable cell.
+   */
+  private findNextFocusableCell;
+  /**
+   * Deletes cells in a given row from start index to end index.
+   *
+   * @param {RTETableRowBlock} row - The table row block.
+   * @param {number} startCellIndex - The start index of the cell to delete.
+   * @param {number} endCellIndex - The end index of the cell to delete.
+   */
+  private deleteCellsInRow;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/delete-table-row-strategy.d.ts

@@ -0,0 +1,28 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { DeleteTableRowAction } from '../actions/delete-table-row-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy class for handling the deletion of table rows.
+ */
+export declare class DeleteTableRowStrategy extends ActionHandleStrategy<DeleteTableRowAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: DeleteTableRowAction, target: RTETableBlock): void;
+  /**
+   * Removes the specified row from its parent table section.
+   * // TODO: Add handling for when selected row has or in merge column.
+   *
+   * @param {RTETableRowBlock} rowToBeRemoved The row to be removed.
+   */
+  private removeRow;
+  /**
+   * Get the future focus row after deletion.
+   *
+   * @param {RTETableRowBlock} startRow - The first row to be deleted.
+   * @param {RTETableRowBlock} endRow - The last row to be deleted.
+   * @param {RTETableBlock} table - The table containing the rows.
+   * @returns {Nullable<RTETableRowBlock>} The row to be focused after deletion.
+   */
+  private getFutureFocusRow;
+}

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

@@ -0,0 +1,27 @@
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { InsertTableBlockAction } from '../actions/insert-table-block-action';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle the insertion of a block into the rich text editor.
+ */
+export declare class InsertTableBlockStrategy extends ActionHandleStrategy<InsertTableBlockAction, RTEBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTableBlockAction, target: RTEBlock): void;
+  /**
+   * Create a table block with the specified number of rows and columns.
+   *
+   * @param {number} row - The number of rows in the table.
+   * @param {number} column - The number of columns in the table.
+   * @returns {RTETableBlock} The created table block.
+   */
+  private createTableBlock;
+  /**
+   * We need to get the correct block if the current target is a block element to avoid nesting blocks.
+   *
+   * @param {RTEBlock} currentTarget - The current target block or content.
+   * @returns {Nullable<RTEBlock>} The reference block.
+   */
+  private getReferenceBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/insert-table-column-strategy.d.ts

@@ -0,0 +1,19 @@
+import { RTETableBlock } from '../dto/table-block';
+import { InsertTableColumnAction } from '../actions/insert-table-column-action';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the insertion of a table column into the RTETable.
+ */
+export declare class InsertTableColumnStrategy extends TableColumnStrategy<InsertTableColumnAction> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTableColumnAction, target: RTETableBlock): void;
+  /**
+   * Generate a new table cell based on the original cell type.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} originalCell The original table cell block to base the new cell on.
+   * @returns {RTETableCellBlock | RTETableHeadCellBlock} The newly generated table cell block.
+   */
+  private generateTableCell;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/insert-table-row-strategy.d.ts

@@ -0,0 +1,27 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertTableRowAction } from '../actions/insert-table-row-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy class for handling the insertion of a new row into a table.
+ */
+export declare class InsertTableRowStrategy extends ActionHandleStrategy<InsertTableRowAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertTableRowAction, target: RTETableBlock): void;
+  /**
+   * Checks if a header row should be inserted based on the selected rows and position.
+   *
+   * @param {RTETableRowBlock} refBlock - The reference table row block.
+   * @param {InsertTableRowDirection} direction - The direction to insert the new row (above or below).
+   * @returns {boolean} True if a header row should be inserted, false otherwise.
+   */
+  private shouldInsertHeaderRow;
+  /**
+   * Get the default cell block template.
+   *
+   * @param {string} cellType - The type of the cell block.
+   * @returns {VegaRTETableCellBlock | VegaRTETableHeadCellBlock} The default cell block template.
+   */
+  private getDefaultCellBlockTemplate;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/select-table-column-strategy.d.ts

@@ -0,0 +1,12 @@
+import { RTETableBlock } from '../dto/table-block';
+import { SelectTableColumnAction } from '../actions/select-table-column-action';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the selection of a table column.
+ */
+export declare class SelectTableColumnStrategy extends TableColumnStrategy<SelectTableColumnAction> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: SelectTableColumnAction, target: RTETableBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/table-column-strategy.abstract.d.ts

@@ -0,0 +1,20 @@
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import type { RTETableCellBlock } from '../dto/table-cell-block';
+import type { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+/**
+ * Abstract base strategy for handling table column operations.
+ * Provides common functionality for all column-related strategies.
+ */
+export declare abstract class TableColumnStrategy<TAction extends ModifyContentAction | AnnotationAction> extends ActionHandleStrategy<TAction, RTEBlock> {
+  /**
+   * Finds the index range of cells within a table row.
+   * Returns the start and end indices of the given cell range.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} cellRange - The range of table cells to find indices for.
+   * @returns {[number, number]} A tuple containing the start and end indices.
+   */
+  protected getBoundaryCellIndexOfRow(cellRange: (RTETableCellBlock | RTETableHeadCellBlock)[]): [number, number];
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-row-strategy.d.ts

@@ -0,0 +1,41 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { ToggleHeaderRowAction } from '../actions/toggle-header-row-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Strategy class for handling converting selected rows to header rows or reverting them back to normal rows.
+ */
+export declare class ToggleHeaderRowStrategy extends ActionHandleStrategy<ToggleHeaderRowAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ToggleHeaderRowAction, target: RTETableBlock): void;
+  /**
+   * Converts normal rows to header rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  private convertToHeaderRows;
+  /**
+   * Converts header rows back to normal rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  private revertToBodyRows;
+  /**
+   * Converts a table data cell to a table header cell.
+   *
+   * @param {RTETableHeadCellBlock} cell - The table cell block to convert.
+   * @returns {RTETableHeadCellBlock} The converted table header cell block.
+   */
+  private convertTdToTh;
+  /**
+   * Converts table header cells to table body cells.
+   *
+   * @param {RTETableRowBlock} row - The table row block containing the cells.
+   * @param {Nullable<RTETableRowBlock>} referenceRow - The reference row for comparison.
+   * @returns {RTETableCellBlock[]} The converted table body cell blocks.
+   */
+  private convertThToTd;
+}