@globalpayments/vega 2.92.0 → 2.93.0

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/insert-paste-handler.d.ts

@@ -9,6 +9,31 @@ export declare class InsertPasteHandler extends BaseHandler {
    * @param {InputEvent} event - Paste event.
    */
   handleEvent(event: InputEvent): void;
+  /**
+   * Inserts plain-text paste content into the current text node at caret position.
+   *
+   * @param {RTEPastePayload} payload - Clipboard payload.
+   * @param {RTERange} currentRange - Current selection range.
+   * @returns {boolean} True when inline insertion is handled.
+   */
+  private insertPlainTextInline;
+  /**
+   * Determines whether the payload should be inserted as inline plain text.
+   *
+   * @param {RTEPastePayload} payload - Clipboard payload.
+   * @param {RTERange} currentRange - Current selection range.
+   * @param {RTENode[]} selectedNodes - Currently selected nodes.
+   * @returns {boolean} True when inline plain-text insertion should be used.
+   */
+  private shouldPasteAsInlinePlainText;
+  /**
+   * Analyzes HTML content to extract plain text and detect inline formatting,
+   * parsing the HTML once to avoid redundant StylePreservation and DOMParser calls.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {HtmlAnalysisResult} Analysis result with plainText and hasFormatting properties.
+   */
+  private analyzeHtmlContent;
   /**
    * Insert the blocks to root
    *
@@ -16,15 +41,17 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private insertBlocksToRoot;
   /**
-   * Insert the blocks to content
+   * Insert the blocks into the current content block at the specified range.
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @param { RTERange } rteRange - rteRange
    */
   private insertBlocksToContent;
   /**
    * Insert the blocks before to current block
    *
    * @param { RTEContentBlock[]} blocks - blocks
+   * @param { RTERange } rteRange - rteRange
    */
   private insertBlocksBeforeEmptyBlock;
   /**
@@ -35,9 +62,24 @@ export declare class InsertPasteHandler extends BaseHandler {
    */
   private parsePastedElements;
   /**
-   * Moves the caret to the next block element in a rich text editor.
+   * Extracts readable plain text from clipboard HTML.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {string} - Plain text extracted from HTML.
+   */
+  private extractPlainTextFromHtml;
+  /**
+   * Builds plain-text paragraph blocks when element strategy parsing returns no output.
+   *
+   * @param {string} text - Plain text clipboard content.
+   * @returns {RTEContentBlock[]} Fallback text blocks.
+   */
+  private buildPlainTextFallbackBlocks;
+  /**
+   * Moves the caret to a block element in a rich text editor after paste.
    *
-   * @param {RTEBlock} newBlock - Represents a new create block element in a rich text editor.
+   * @param {RTEBlock} newBlock - Block element to move the caret to.
+   * @param {boolean} atEnd - When true, places the caret after the last character of the block's last node; otherwise at offset 0 of the first node.
    */
   private switchCaretPositionToNextElement;
   /**
@@ -47,4 +89,73 @@ export declare class InsertPasteHandler extends BaseHandler {
    * @returns {string} - The formatted HTML string.
    */
   private parsePlainText;
+  /**
+   * Detects whether plain text likely represents source code.
+   *
+   * @param {string} content - Clipboard plain text content.
+   * @returns {boolean} True when the content should render as a code block.
+   */
+  private shouldRenderAsCodeBlock;
+  /**
+   * Removes pasted website artifacts that can cause visual regressions in the editor,
+   * such as heading anchor tooltips and empty wrappers.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private normalizeImportedHtmlArtifacts;
+  /**
+   * Removes heading copy-link/tooltip artifacts copied from documentation pages.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private removeHeadingArtifacts;
+  /**
+   * Removes empty block wrappers introduced by web copy/paste.
+   *
+   * @param {HTMLElement} body - Parsed clipboard html body.
+   */
+  private removeEmptyBlocks;
+  /**
+   * Checks whether a block is visually empty and safe to remove.
+   *
+   * @param {HTMLElement} element - Block element to inspect.
+   * @returns {boolean} True when the block has no visible content.
+   */
+  private isEmptyVisualBlock;
+  /**
+   * Checks whether a text/html payload is effectively plain text.
+   *
+   * Some sources (e.g. terminals, code editors) place the copied text inside an
+   * off-screen / visually hidden wrapper such as
+   * `<pre><div style="position: absolute; left: -9999px;">text</div></pre>`.
+   * Preserving that markup as rich content would render the pasted text
+   * off-screen (appearing empty), so such payloads are treated as plain text.
+   *
+   * @param {string} html - Clipboard text/html payload.
+   * @returns {boolean} True when the payload has no visible rich content.
+   */
+  private shouldTreatAsPlainTextPayload;
+  /**
+   * Returns true when a CSS style string contains bold, italic, underline,
+   * strikethrough, or color declarations.
+   *
+   * @param {string} style - Inline CSS style string.
+   * @returns {boolean} True when the style contains rich formatting.
+   */
+  private styleContainsRichFormatting;
+  /**
+   * Determines whether an element is visually hidden or rendered off-screen
+   * via its inline style, indicating a clipboard plain-text wrapper.
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} True when the element is hidden or off-screen.
+   */
+  private isVisuallyHiddenElement;
+  /**
+   * Resolves paste payload from DataTransfer and synthetic-event fallback payload.
+   *
+   * @param {InputEvent} event - Paste event.
+   * @returns {RTEPastePayload} - Paste payload.
+   */
+  private getPastePayload;
 }

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

@@ -105,27 +105,36 @@ export declare class SelectionController extends AutoRunWhenReRenderTaskQueueSli
    */
   protected doTask: () => Promise<void>;
   /**
-   * Scroll the editor's scrollable viewport so the caret stays visible.
-   * Setting the selection range programmatically does not trigger the browser's
-   * native auto-scroll, so when the cursor is moved (e.g. after inserting a
-   * function block) it can land outside the visible area of a fixed-height
-   * (rows) editor. This keeps the caret within view.
+   * Keep the caret visible after the range is restored.
    *
-   * Note: This method performs getBoundingClientRect() reads and is called during
-   * the re-render task path every time the saved selection is restored.
+   * Applying a range in code does not trigger browser auto-scroll. We first
+   * check whether the caret is already visible, and only then call
+   * scrollIntoView with center alignment. This works for both fixed-height
+   * content hosts (rows mode) and page scrolling (stretch mode), while avoiding
+   * unnecessary jumps during normal typing.
    *
    * @param {Range} range - The range that was applied to the selection.
    */
   private scrollCaretIntoView;
   /**
-   * Get the bounding rect of the caret for the given range.
-   * A collapsed range inside an empty node can return an empty rect, so in that
-   * case fall back to the nearest element's bounding rect.
+   * Resolve the nearest element for the caret start container.
    *
-   * @param {Range} range - The range to measure.
-   * @returns {Nullable<DOMRect>} The caret bounding rect, or null if it cannot be resolved.
+   * @param {Range} range - The range to inspect.
+   * @returns {Nullable<HTMLElement>} The caret's nearest element, or null.
    */
-  private getCaretRect;
+  private getCaretElement;
+  /**
+   * Determine whether the caret is currently visible within the viewport.
+   *
+   * The visible area is the intersection of the window and the content host,
+   * because in fixed-height (`rows`) mode the host clips its content while in
+   * the stretch mode the window is the binding constraint.
+   *
+   * @param {Range} range - The range that was applied to the selection.
+   * @param {HTMLElement} element - The caret's nearest element.
+   * @returns {boolean} True when the caret is fully inside the visible area.
+   */
+  private isCaretWithinViewport;
   /**
    * Save the current selection range detail
    */

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

@@ -1,6 +1,7 @@
 import { ToolbarInternalButtonConfig } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 import { VisualModeToolbarButtonSlimmer } from './visual-mode-toolbar-button-slimmer.abstract';
+import { Nullable } from '../../../../../types/general';
 export declare type InsertImageType = 'upload' | 'url';
 export declare type InsertImageItem = {
   key: InsertImageType;
@@ -10,7 +11,7 @@ export declare type InsertURLForm = {
   url: string;
 };
 export declare class ImageToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
-  private static readonly items;
+  private static readonly allItems;
   protected host: VegaRichTextEditor['host'];
   protected insertImageController: VegaRichTextEditor['insertImageController'];
   protected imageInsertedEventEmitter: VegaRichTextEditor['imageInsertedEventEmitter'];
@@ -24,17 +25,24 @@ export declare class ImageToolbarButtonSlimmer extends VisualModeToolbarButtonSl
   private currentSelectedBlocks;
   private currentSelectedNodes;
   constructor();
-  protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
+  protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): Nullable<HTMLElement>;
+  protected onClick(): void;
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   private renderDropdownContent;
+  private getItems;
   private renderUploadInput;
   private renderInsertURLModal;
   private addDropdownObserver;
   private addModalCancelObserver;
   private addModalInsertObserver;
+  private getImageExtensionConfig;
+  private isImageUploadEnabled;
+  private isImageURLInsertionEnabled;
+  private shouldRenderDropdown;
   private insertURLImage;
   private handleDropdownItemClick;
+  private openInsertURLModal;
   /**
    * The below method is e2e-test covered in
    * @see{module:should-update-url-properly-when-upload-images}

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

@@ -4,6 +4,7 @@ export declare class VegaRichTextEditorToolbarButtonRenderer extends VegaSlimmer
   private hidden;
   private selected;
   private showArrowIcon;
+  private arrowIcon;
   private icon;
   private iconColor;
   private clickEventEmitter;

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

@@ -39,6 +39,12 @@ export declare class VegaRichTextEditorToolbarButton {
    * @vegaVersion 2.34.0
    */
   showArrowIcon: boolean;
+  /**
+   * Specifies the arrow icon name when `showArrowIcon` is enabled.
+   *
+   * @vegaVersion 2.93.0
+   */
+  arrowIcon: string;
   /**
    * Specifies whether the toolbar button in the rich text editor is represented by an icon.
    *

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

@@ -163,10 +163,10 @@ export declare class VegaRichTextEditor {
    */
   hint: string;
   /**
-   * Specifies editable section rows for the rich text editor.
-   * When not set, the editor uses stretching behavior with a default visual height of 5 rows.
-   * When set, the editor height is fixed and content overflow is scrollable.
-   * The value accepts integers ≥ 2; for optimal display, values below 2 are internally normalized to 5 rows.
+   * Specifies the number of visible rows for the rich text editor.
+   * - If not specified, the editor uses a flexible height with a default of 5 rows.
+   * - If specified, the editor height becomes fixed, and overflowing content is scrollable.
+   * - Accepts integer values ≥ 2. For optimal display, values below 2 are automatically normalized to 5 rows.
    *
    * @vegaVersion 2.34.0
    */

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

@@ -7,7 +7,7 @@ import { VegaRichTextImageEditorChangeDetail, VegaRichTextImageEditorSizeType }
 import { TranslationSlimmer } from '../../../helpers/slimmers/translation';
 /**
  * This is an internal used component and shouldn't be used by clients,
- *    it doesn't show up in storybook either.
+ *    it is not part of the public component surface.
  *
  * @vegaVersion 2.34.0
  */

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

@@ -7,7 +7,7 @@ import { VegaRichTextLinkEditorChangeDetail, VegaRichTextLinkEditorStatus, VegaR
 import { TranslationSlimmer } from '../../../helpers/slimmers/translation';
 /**
  * This is an internal used component and shouldn't be used by clients,
- *    it doesn't show up in storybook either.
+ *    it is not part of the public component surface.
  *
  * @vegaVersion 2.34.0
  */

package/dist/types/components/vega-table/interface.d.ts

@@ -129,6 +129,24 @@ export declare type VegaTableColumnConfig = {
    * Used for editable cell customize render in editing mode
    */
   renderFormItem?: VegaTableCellFormItemRenderFunction;
+  /**
+   * Number of columns this cell should span, or a per-row resolver function.
+   * Values of `undefined`, `null`, and `1` are treated as no spanning — no `colspan` attribute,
+   * no `aria-colspan` attribute, no cells skipped.
+   *
+   * When the resolved span would cross a pinned-column boundary or extend past the end of the
+   * row, the span is silently clamped to the legal upper bound and a `console.warn` is emitted
+   * (once per column key) in dev builds. A breakpoint-hidden column does NOT shrink a span: the
+   * span mirrors its declared value across a `display: none` column (matching the header group
+   * `colSpan` precedent), so the body grid stays column-aligned with the header. This mirror is
+   * not a clamp and never warns.
+   *
+   * Cells whose effective `colSpan >= 2` are forced read-only — editable form items are not
+   * rendered even when the column declares `editable`, `formItemType`, or `renderFormItem`.
+   *
+   * @vegaVersion 2.93.0
+   */
+  colSpan?: number | null | ((value: unknown, record: VegaTableDataSourceItem, index: number) => number);
 };
 /**
  * Type alias for composite column configurations (grouping or leaf models).

package/dist/types/components/vega-table/slimmers/controllers/dto/column-render-input-model.d.ts

@@ -61,6 +61,19 @@ export declare class ColumnRenderInputModel {
    * @returns {ColumnRenderInputModel[]} Array of root-level ColumnRenderInputModel nodes (the render forest).
    */
   static from(rootModel: ColumnStructureModel): ColumnRenderInputModel[];
+  /**
+   * Create a new render input that merges pinned-boundary flags from a set of spanned leaves.
+   *
+   * Used when a body cell with `colSpan > 1` consumes neighboring leaves. The spanning cell
+   * must inherit boundary indicators (`isLeftEndPinned`, `isRightStartPinned`, `isNoPinnedEnd`)
+   * from any consumed leaf that carries them, so the pinned-boundary visual (divider/shadow)
+   * remains visible on the spanning cell.
+   *
+   * @param {ColumnRenderInputModel} base - The render input of the originating (leftmost) leaf.
+   * @param {ColumnRenderInputModel[]} spannedLeaves - All leaves consumed by the span (including base).
+   * @returns {ColumnRenderInputModel} A new instance with OR-merged boundary flags.
+   */
+  static withMergedBoundaries(base: ColumnRenderInputModel, spannedLeaves: ColumnRenderInputModel[]): ColumnRenderInputModel;
   /**
    * True when the provided structure model is the last left-pinned sibling in its parent's children.
    * Used to mark boundary nodes for left-pinned groups.

package/dist/types/components/vega-table/slimmers/controllers/vega-table-body-col-span-controller.d.ts

@@ -0,0 +1,43 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+import { VegaTableColumnConfig, VegaTableDataSourceItem } from '../../interface';
+import { Nullable } from '../../../../types/general';
+import { ColumnRenderInputModel } from './dto/column-render-input-model';
+import { BodyColSpanResult } from '../renderers/vega-table-body-col-span-resolver';
+/**
+ * Per-row body colspan controller.
+ *
+ * Centralizes the source-data body colSpan computation that was previously scattered across the
+ * cell renderer (cache + per-cell resolve) and the row renderer (imperative `skipCount`). It owns
+ * the once-per-key warning cache and exposes {@link resolveRow}, which computes the colspan result
+ * for every leaf in a row in a single pass so renderers can consume the result declaratively.
+ *
+ * The structural shape (a {@link VegaSlimmer} controller reading component fields) mirrors the
+ * main-branch `VegaTableExpandRowController` paradigm.
+ */
+export declare class VegaTableBodyColSpanController extends VegaSlimmer {
+  columns: VegaTable['columns'];
+  private warnedColSpanKeys;
+  private lastWarnedColumnsRef;
+  /**
+   * Resolve the effective colspan for every leaf cell in a single source-data row.
+   *
+   * Walks the row left-to-right, resolving each non-consumed leaf's span and marking the leaves
+   * consumed by a span as `null` so the caller can skip them declaratively (no mutable
+   * `skipCount` orchestration). The returned array is index-aligned with `leaves`.
+   *
+   * @param {VegaTableDataSourceItem} record - The row data record.
+   * @param {number} rowIndex - Zero-based index of the row in the current data set.
+   * @param {ColumnRenderInputModel[]} leaves - All leaf render inputs for the table (ordered).
+   * @returns {Array<Nullable<BodyColSpanResult>>} One entry per leaf: a {@link BodyColSpanResult}
+   *   for a cell to render, or `null` for a leaf consumed by a preceding spanning cell.
+   */
+  resolveRow(record: VegaTableDataSourceItem, rowIndex: number, leaves: ColumnRenderInputModel[]): Array<Nullable<BodyColSpanResult>>;
+  /**
+   * Find the column config that backs a leaf render input.
+   *
+   * @param {ColumnRenderInputModel} renderInput - The leaf render input.
+   * @returns {Nullable<VegaTableColumnConfig>} The matching column config, or `undefined`.
+   */
+  findColumn(renderInput: ColumnRenderInputModel): Nullable<VegaTableColumnConfig>;
+}

package/dist/types/components/vega-table/slimmers/renderers/vega-table-body-col-span-resolver.d.ts

@@ -0,0 +1,38 @@
+import { ColumnRenderInputModel } from '../controllers/dto/column-render-input-model';
+import { VegaTableColumnConfig, VegaTableDataSourceItem } from '../../interface';
+/**
+ * Result of resolving the effective colspan for a single body cell.
+ */
+export declare type BodyColSpanResult = {
+  /**
+   * The `colspan` HTML attribute value for the `<td>` and the `aria-colspan` mirrored on the host.
+   * Equal to the structural span after end-of-row / pinned-boundary clamping. Breakpoint-hidden
+   * columns are **not** a shrink trigger: the span retains its declared value across a
+   * `display: none` column (mirror, never shrink), matching the header group `colSpan` precedent
+   * so the body grid stays column-aligned with the header.
+   */
+  htmlColspan: number;
+  /**
+   * Number of subsequent leaf render inputs to skip (consumed by this span).
+   * Consumers must advance their column pointer by this amount after rendering the spanning cell.
+   */
+  skipCount: number;
+};
+/**
+ * Resolve the effective body-cell colspan for a single source-data row cell.
+ *
+ * Clamps the declared span so it never runs past the end of the row nor crosses a
+ * pinned ↔ unpinned column boundary. Structural clamps (end-of-row / pinned boundary) emit a
+ * warning once per column key (tracked via the caller-supplied {@link warnedKeys} set).
+ * Breakpoint-hidden columns are **not** clamped — the span mirrors across a `display: none`
+ * column (matching header group colSpan) so the body grid stays column-aligned with the header.
+ *
+ * @param {VegaTableColumnConfig} column - The column configuration for the spanning cell.
+ * @param {VegaTableDataSourceItem} record - The row data record.
+ * @param {number} rowIndex - Zero-based index of the row in the current data set.
+ * @param {number} leafIndex - Index of this column in the flattened leaf render-input array.
+ * @param {ColumnRenderInputModel[]} allLeaves - All leaf render inputs for the table (ordered).
+ * @param {Set<string>} warnedKeys - Per-instance set tracking column keys that have already received a clamping warning.
+ * @returns {BodyColSpanResult} Resolved spanning metadata for the cell.
+ */
+export declare function resolveBodyColSpan(column: VegaTableColumnConfig, record: VegaTableDataSourceItem, rowIndex: number, leafIndex: number, allLeaves: ColumnRenderInputModel[], warnedKeys: Set<string>): BodyColSpanResult;

package/dist/types/components/vega-table/slimmers/renderers/vega-table-cell-renderer.d.ts

@@ -2,13 +2,22 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTableDataSourceItem } from '../../interface';
 import { VegaTable } from '../../vega-table';
 import { ColumnRenderInputModel } from '../controllers/dto/column-render-input-model';
+import { BodyColSpanResult } from './vega-table-body-col-span-resolver';
 export declare class VegaTableCellRenderer extends VegaSlimmer {
   rowKey: VegaTable['rowKey'];
-  columns: VegaTable['columns'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   vegaTableEditableController: VegaTable['vegaTableEditableController'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
-  render(renderInput: ColumnRenderInputModel, record: VegaTableDataSourceItem, index: number): HTMLTableCellElement;
+  vegaTableBodyColSpanController: VegaTable['vegaTableBodyColSpanController'];
+  render(renderInput: ColumnRenderInputModel, record: VegaTableDataSourceItem, index: number, colSpanResult?: BodyColSpanResult): HTMLTableCellElement;
+  /**
+   * Build a render input with merged boundary flags from all leaves consumed by a body colSpan.
+   *
+   * @param {ColumnRenderInputModel} baseInput - The starting leaf's render input.
+   * @param {BodyColSpanResult} colSpanResult - The resolved span result (provides skipCount).
+   * @returns {ColumnRenderInputModel} A render input with OR-merged boundary flags.
+   */
+  private getMergedRenderInputForSpan;
   private renderTableCellContent;
   /**
    * Generate edit component by

package/dist/types/components/vega-table/slimmers/renderers/vega-table-pinned-renderer.d.ts

@@ -8,6 +8,9 @@ export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   private previouslyStyledCells;
+  private dynamicRightDividerCells;
+  private dynamicLeftDividerCells;
+  private dynamicHideRightBorderCells;
   private clearPinnedPositionsTaskQueue;
   componentDidLoad(): void;
   componentDidRender(): Promise<void>;
@@ -15,6 +18,7 @@ export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   private updateTableCellPinnedPosition;
   private getRowShadowThWidths;
   private getLeafWidths;
+  private syncColspanForHiddenColumns;
   private updateCellPinnedPosition;
   private updateTableRowPinnedPosition;
   private clearAllPinnedPositions;

package/dist/types/components/vega-table/slimmers/renderers/vega-table-row-renderer.d.ts

@@ -5,6 +5,7 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   rowClickEventEmitter: VegaTable['rowClickEventEmitter'];
   vegaTableEditableController: VegaTable['vegaTableEditableController'];
   vegaTableCellRenderer: VegaTable['vegaTableCellRenderer'];
+  vegaTableBodyColSpanController: VegaTable['vegaTableBodyColSpanController'];
   striped: VegaTable['striped'];
   rowDivider: VegaTable['rowDivider'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];

package/dist/types/components/vega-table/vega-table-cell/slimmers/controllers/vega-table-row-state-subscriber.d.ts

@@ -3,7 +3,7 @@ import { VegaTableCell } from '../../vega-table-cell';
 /**
  * Controller for the table row states
  */
-export declare class VegaTableRowStateSubscriber extends SubStateObserverSlimmer<HTMLVegaTableCellElement> {
+export declare class VegaTableRowStateSubscriber extends SubStateObserverSlimmer<HTMLVegaTableRowElement> {
   checked: VegaTableCell['checked'];
   expanded: VegaTableCell['expanded'];
   striped: VegaTableCell['striped'];

package/dist/types/components/vega-table/vega-table-cell/vega-table-cell.d.ts

@@ -60,6 +60,15 @@ export declare class VegaTableCell {
    * @vegaVersion 1.44.0
    */
   width?: string;
+  /**
+   * Number of columns this cell should span horizontally.
+   * Values of `undefined`, `null`, and `1` are treated as no spanning.
+   * When the effective span is `>= 2`, a `colspan` attribute is set on the inner `<td>`
+   * and `aria-colspan` is exposed on the host element for assistive technology.
+   *
+   * @vegaVersion 2.93.0
+   */
+  colSpan?: number;
   render(): VegaTableCell;
   private getCellOverflowClass;
   private onMouseEnter;

package/dist/types/components/vega-table/vega-table-foot-cell/slimmers/renderers/vega-table-foot-cell-renderer.d.ts

@@ -4,5 +4,6 @@ export declare class VegaTableFootCellRenderer extends VegaSlimmer {
   host: VegaTableFootCell['host'];
   breakpoint: VegaTableFootCell['breakpoint'];
   textAlign: VegaTableFootCell['textAlign'];
+  colSpan: VegaTableFootCell['colSpan'];
   render(): VegaTableFootCell;
 }

package/dist/types/components/vega-table/vega-table-foot-cell/vega-table-foot-cell.d.ts

@@ -41,5 +41,14 @@ export declare class VegaTableFootCell {
    * @vegaVersion 2.68.1
    */
   width?: string;
+  /**
+   * Number of columns this foot cell should span horizontally.
+   * Values of `undefined`, `null`, and `1` are treated as no spanning.
+   * When the effective span is `>= 2`, a `colspan` attribute is set on the inner `<td>`
+   * and `aria-colspan` is exposed on the host element for assistive technology.
+   *
+   * @vegaVersion 2.93.0
+   */
+  colSpan?: number;
   render(): VegaTableFootCell;
 }

package/dist/types/components/vega-table/vega-table.d.ts

@@ -5,6 +5,7 @@ import { DragDropEventPayload, ResponsiveType } from '../../types/ui.type';
 import { VegaTableChangePropType, VegaTableColumnConfig, VegaTableDataSourceItem, VegaTableDensityType, VegaTablePagination, VegaTableRowClickPropType, VegaTableRowSelectionConfig, VegaTableRowSelectProp, VegaTableSelectAllProp, VegaTableScrollConfig, VegaTableSortConfig, VegaTableRowSelectAllEventDetail, VegaTableRowSelectEventDetail, VegaTableRowExpandEventDetail, VegaTableGroupColumnConfig, VegaTableRowExpandableType } from './interface';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaTableCellRenderer } from './slimmers/renderers/vega-table-cell-renderer';
+import { VegaTableBodyColSpanController } from './slimmers/controllers/vega-table-body-col-span-controller';
 import { VegaTableExpandRowController } from './slimmers/controllers/vega-table-expand-row-controller';
 import { VegaTableRowSelectionController } from './slimmers/controllers/vega-table-row-selection-controller';
 import { VegaTableDataSourceController } from './slimmers/controllers/vega-table-data-source-controller';
@@ -48,6 +49,7 @@ export declare class VegaTable {
   protected readonly vegaTableBodyRenderer: VegaTableBodyRenderer;
   protected readonly vegaTableRowRenderer: VegaTableRowRenderer;
   protected readonly vegaTableCellRenderer: VegaTableCellRenderer;
+  protected readonly vegaTableBodyColSpanController: VegaTableBodyColSpanController;
   protected readonly vegaTablePaginationRenderer: VegaTablePaginationRenderer;
   protected readonly vegaTableScrollContainerRenderer: VegaTableScrollContainerRenderer;
   protected readonly vegaTableRowSelectionController: VegaTableRowSelectionController;

package/dist/types/components/vega-time-picker/slimmers/controllers/vega-time-picker-range-dropdown-controller.d.ts

@@ -4,6 +4,7 @@ import { TimeRangeIndex } from '../../types';
 /** The `VegaTimePickerRangeDropdownController` class is responsible for managing the dropdown menu for selecting a range of time in the VegaTimePicker component. */
 export declare class VegaTimePickerRangeDropdownController extends ElementAppenderSlimmer {
   positionRelativeTo: VegaTimePicker['positionRelativeTo'];
+  vegaDropdownProps: VegaTimePicker['vegaDropdownProps'];
   mode: VegaTimePicker['mode'];
   rangeDropdownRenderer: VegaTimePicker['rangeDropdownRenderer'];
   rangeInputRenderer: VegaTimePicker['rangeInputRenderer'];

package/dist/types/components/vega-time-picker/slimmers/controllers/vega-time-picker-single-dropdown-controller.d.ts

@@ -9,6 +9,7 @@ export declare class VegaTimePickerSingleDropdownController extends ElementAppen
   timeFormat: VegaTimePicker['timeFormat'];
   value: VegaTimePicker['value'];
   positionRelativeTo: VegaTimePicker['positionRelativeTo'];
+  vegaDropdownProps: VegaTimePicker['vegaDropdownProps'];
   selectedTimeValue: VegaTimePicker['selectedTimeValue'];
   singleInputRenderer: VegaTimePicker['singleInputRenderer'];
   rangeInputRenderer: VegaTimePicker['rangeInputRenderer'];

package/dist/types/components/vega-time-picker/types.d.ts

@@ -1,5 +1,6 @@
 import { AmPm } from '../../types/general';
 import { DatePickerModeType, DatePickerValueType } from '../vega-date-picker/types';
+import { ElementAppenderShowConfig } from '../../helpers/ui/element-appender';
 
 /**
  * Data source categories used in the time picker dropdown.
@@ -52,3 +53,9 @@ export type TimePickerModeType = DatePickerModeType;
  * Value type for the time picker, parameterised by mode.
  */
 export type TimePickerValueType<T extends TimePickerModeType> = DatePickerValueType<T>;
+
+/**
+ * Partial properties used to configure the positioning behavior of the
+ *    time picker's dropdown.
+ */
+export type VegaDropdownPropsForTimePicker = Partial<Pick<ElementAppenderShowConfig, 'isScreenPosition'>>;

package/dist/types/components/vega-time-picker/vega-time-picker.d.ts

@@ -5,7 +5,7 @@ import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
 import { VegaTimePickerLabelRenderer } from './slimmers/renderers/vega-time-picker-label-renderer';
 import { VegaTimePickerSingleInputRenderer } from './slimmers/renderers/vega-time-picker-single-input-renderer';
-import { TimePickerDropdownSource, TimePickerModeType, TimePickerValueType, TimeValue } from './types';
+import { TimePickerDropdownSource, TimePickerModeType, TimePickerValueType, TimeValue, VegaDropdownPropsForTimePicker } from './types';
 import { VegaTimePickerSingleDropdownRenderer } from './slimmers/renderers/vega-time-picker-single-dropdown-renderer';
 import { VegaTimePickerValueController } from './slimmers/controllers/vega-time-picker-value-controller';
 import { VegaTimePickerSingleDropdownController } from './slimmers/controllers/vega-time-picker-single-dropdown-controller';
@@ -207,6 +207,16 @@ export declare class VegaTimePicker {
    * @vegaVersion 1.12.0
    */
   positionRelativeTo: string;
+  /**
+   * Provides partial dropdown positioning properties for the time picker.
+   *
+   * Set `isScreenPosition: true` to position the dropdown relative to
+   *    the viewport.
+   *
+   * @vegaVersion 2.93.0
+   */
+  vegaDropdownProps: VegaDropdownPropsForTimePicker;
+  watchVegaDropdownProps(): void;
   /**
    * An event emitter notifying changes in the value of the time picker.
    *