@globalpayments/vega 2.100.0 → 2.101.0

package/dist/types/components/vega-calendar/slimmers/common/renderers/vega-calendar-event-item-renderer.d.ts

@@ -10,9 +10,15 @@ export declare class VegaCalendarEventItemRenderer extends VegaSlimmer {
   protected eventClickEmitter: VegaCalendar['eventClickEmitter'];
   protected timeFormat: VegaCalendar['timeFormat'];
   protected enabledEventPreview: VegaCalendar['enabledEventPreview'];
+  protected eventPreviewEmitter: VegaCalendar['eventPreviewEmitter'];
   protected renderer: VegaCalendar['renderer'];
+  protected eventPreviewPopoverProps: VegaCalendar['eventPreviewPopoverProps'];
   protected eventPreviewPopoverController: VegaCalendar['eventPreviewPopoverController'];
   protected eventPreviewActionsController: VegaCalendar['eventPreviewActionsController'];
+  /**
+   * While it is a single event and the trigger is hover, we should show the preview popover when mouse enter on the event item.
+   */
+  previewingEvent(event: CalendarEvent, targetCalendarViewDate: CalendarDate, isGroupEvent: boolean): void;
   /**
    * render event component
    *
@@ -22,6 +28,10 @@ export declare class VegaCalendarEventItemRenderer extends VegaSlimmer {
    * @returns {HTMLVegaCalendarEventElement} calendar event element
    */
   render(item: CalendarEvent, classMap: Record<string, boolean>, targetCalendarViewDate: CalendarDate, isGroupEvent?: boolean): HTMLVegaCalendarEventElement;
+  /**
+   * While it is a group event or the trigger is click with single event, we should show the preview popover when click on the event item.
+   */
+  private onEventClick;
   /**
    * emit vega click event
    *
@@ -29,4 +39,12 @@ export declare class VegaCalendarEventItemRenderer extends VegaSlimmer {
    */
   private handleEventClick;
   private setupPreviewContainer;
+  /**
+   * 1. The popover is not closed immediately when mouse leave.
+   * 2. The event preview popover shares a single preview component.
+   * While a new event item is hovered, it will make previous event popover empty, this will emit the popover flash in view.
+   * To avoid this, we hide the previous preview popover when a new event item is hovered.
+   * Ticket: https://gethired.atlassian.net/browse/VD-9920
+   */
+  private hidePreviousPreviewPopover;
 }

package/dist/types/components/vega-calendar/slimmers/common/renderers/vega-calendar-event-preview-popover-renderer.d.ts

@@ -10,9 +10,18 @@ export declare class VegaCalendarEventPreviewPopoverRenderer extends VegaSlimmer
   protected timeFormat: VegaCalendar['timeFormat'];
   protected eventItemRenderer: VegaCalendar['eventItemRenderer'];
   protected enabledEventPreview: VegaCalendar['enabledEventPreview'];
+  protected eventPreviewPopoverProps: VegaCalendar['eventPreviewPopoverProps'];
   protected eventPreviewPopoverController: VegaCalendar['eventPreviewPopoverController'];
+  protected monthEventRenderer: VegaCalendar['monthEventRenderer'];
   private popoverHideObserver;
+  private popoverRefMap;
   render(event: CalendarEvent, targetCalendarViewDate: CalendarDate, classMap: Record<string, boolean>): HTMLElement;
   private renderPreviewPopover;
   private setPopoverHideObserver;
+  private listenPopoverRef;
+  /**
+   * When the mouse enters the popover, if the trigger is hover, we should show the preview popover when mouse enter on the event item.
+   * If the group event is previewing, we should prevent the popover from showing.
+   */
+  private onPopoverMouseEnter;
 }

package/dist/types/components/vega-calendar/slimmers/month-view/renderers/vega-calendar-month-event-renderer.d.ts

@@ -17,6 +17,8 @@ export declare class VegaCalendarMonthEventRenderer extends VegaSlimmer {
   private moreEventsBoxRef;
   private maxMonthDisplayEventsCount;
   private popoverHideObserver;
+  private isGroupEventPreviewingFlag;
+  private groupPopoverRef;
   /**
    * current row dates all events.
    *
@@ -43,6 +45,12 @@ export declare class VegaCalendarMonthEventRenderer extends VegaSlimmer {
    * @returns {Nullable<HTMLVegaBoxElement>} the more events popover box element
    */
   getMoreEventsBoxRef(): Nullable<HTMLVegaBoxElement>;
+  /**
+   * Check if a group event preview is currently being displayed
+   *
+   * @returns {boolean} - True if a group event preview is being displayed, false otherwise
+   */
+  isGroupEventPreviewing(): boolean;
   /**
    * render the current date events
    *
@@ -74,5 +82,5 @@ export declare class VegaCalendarMonthEventRenderer extends VegaSlimmer {
    * @returns {Nullable<CalendarEvent>[][]} new event array
    */
   private hideTheCutOffEvents;
-  private setPopoverHideObserver;
+  private setPopoverObserver;
 }

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

@@ -134,6 +134,16 @@ export type VegaCalendarEventClickInfo = {
 	rawEvent: VegaCalendarRawEvent;
 };
 
+/**
+ * Information provided when a calendar event is previewed (e.g., hovered over or clicked for a popover).
+ */
+export type VegaCalendarEventPreviewInfo = {
+	/**
+	 * The raw event data that was previewed.
+	 */
+	rawEvent: VegaCalendarRawEvent;
+};
+
 /**
  * Information provided when a calendar event is edited.
  */
@@ -325,3 +335,15 @@ export type CalendarEventActionsCallback = (
 	event: VegaCalendarRawEvent,
 	date: VegaCalendarDateType,
 ) => CalendarEventActions;
+
+/**
+ * Configuration options for the event preview popover behavior.
+ */
+export type VegaCalendarEventPreviewPopoverProps = {
+	/**
+	 * Specifies the interaction that triggers the event preview popover.
+	 * - 'click': Popover appears when the event is clicked (default behavior).
+	 * - 'hover': Popover appears when the mouse hovers over the event.
+	 */
+	trigger: 'hover' | 'click';
+};

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

@@ -6,7 +6,7 @@ import { VegaCalendarViewRenderer } from './slimmers/common/renderers/vega-calen
 import { VegaCalendarMonthViewRenderer } from './slimmers/month-view/renderers/vega-calendar-month-view-renderer';
 import { VegaCalendarViewWithTimeRenderer } from './slimmers/day-view/renderers/vega-calendar-view-with-time-renderer';
 import { VegaCalendarTimeLineRenderer } from './slimmers/day-view/renderers/vega-calendar-time-line-renderer';
-import { VegaCalendarChangeEventType, VegaCalendarEventClickInfo, VegaCalendarDateClickInfo, VegaCalendarRawEvent, VegaCalendarViewModeType, DropdownPropsForCalendar, DisabledDate, CalendarEventActionsCallback, VegaCalendarEventEditInfo, VegaCalendarPeriodType } from './types';
+import { VegaCalendarChangeEventType, VegaCalendarEventClickInfo, VegaCalendarDateClickInfo, VegaCalendarRawEvent, VegaCalendarViewModeType, DropdownPropsForCalendar, DisabledDate, CalendarEventActionsCallback, VegaCalendarEventEditInfo, VegaCalendarPeriodType, VegaCalendarEventPreviewPopoverProps, VegaCalendarEventPreviewInfo } from './types';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { CalendarDate, CalendarPeriod, CalendarView } from '../../helpers/calendar';
 import { VegaCalendarViewController } from './slimmers/common/controllers/vega-calendar-view-controller';
@@ -68,6 +68,7 @@ export declare class VegaCalendar {
   protected eventResponsiveController: VegaCalendarEventResponsiveController;
   protected changeEventEmitter: EventEmitSlimmerBase;
   protected eventClickEmitter: EventEmitSlimmerBase;
+  protected eventPreviewEmitter: EventEmitSlimmerBase;
   protected dateDblClickEmitter: EventEmitSlimmerBase;
   protected moreActionClickEmitter: EventEmitSlimmerBase;
   protected dateClickEmitter: EventEmitSlimmerBase;
@@ -213,6 +214,14 @@ export declare class VegaCalendar {
    * @vegaVersion 2.87.0
    */
   getEventPreviewActions: CalendarEventActionsCallback;
+  /**
+   * Configuration options for the event preview popover behavior.
+   * Allows customization of how the popover is triggered (hover or click).
+   * By default, the popover triggers on click.
+   *
+   * @vegaVersion 2.101.0
+   */
+  eventPreviewPopoverProps: VegaCalendarEventPreviewPopoverProps;
   /**
    * Monitors changes in the timezone prop for the calendar.
    */
@@ -230,6 +239,19 @@ export declare class VegaCalendar {
    * @vegaVersion 2.14.0
    */
   change: EventEmitter<VegaCalendarChangeEventType>;
+  /**
+   * An event emitter notifying that a calendar event is ready to review.
+   *
+   * @vegaVersion 2.101.0
+   */
+  vegaEventPreview: EventEmitter<VegaCalendarEventPreviewInfo>;
+  /**
+   * An event emitter notifying that a calendar event is ready to review.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.101.0
+   */
+  eventPreview: EventEmitter<VegaCalendarEventPreviewInfo>;
   /**
    * An event emitter notifying that a component event item is clicked.
    *

package/dist/types/components/vega-flag-icon/slimmers/controllers/vega-flag-icon-controller.d.ts

@@ -13,9 +13,9 @@ export declare class VegaFlagIconController extends VegaSlimmer {
   protected country: VegaFlagIcon['country'];
   private observer;
   /**
-   * componentWillLoad
+   * connectedCallback
    */
-  componentWillLoad(): void;
+  connectedCallback(): void;
   /**
    * disconnectedCallback
    */

package/dist/types/components/vega-input-phone-number/slimmers/renderers/country-select-renderer.d.ts

@@ -47,7 +47,6 @@ export declare class CountrySelectRenderer extends VegaSlimmer {
    * rendering the JSX structure of the component. Here's a breakdown of what it is doing:
    */
   render(): HTMLElement;
-  private renderDropdownPrefixIconWithFlagIcon;
   /**
    * This `renderDropdownItem` function is responsible for rendering a dropdown item for a specific country in
    * the `VegaInputPhoneNumberCountryCodeRenderer` component.

package/dist/types/components/vega-input-select/slimmers/renderers/vega-input-select-prefix-icon-renderer.d.ts

@@ -1,21 +1,9 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaInputSelect } from '../../vega-input-select';
-import { Nullable } from '../../../../types/general';
-/** Manager remote invocation */
 export declare class VegaInputSelectPrefixIconRenderer extends VegaSlimmer {
   host: VegaInputSelect['host'];
   private prefixIcon;
-  private remotePhoneNumberPrefixIconRenderSubject;
-  /**
-   * Component lifecycle - connectedCallback
-   */
-  connectedCallback(): void;
-  /**
-   * Call the render function in input-phone-number.
-   *
-   * @param {unknown[]} args - arguments of remote search function
-   * @returns {Nullable<HTMLVegaFlagIconElement>} - returned vega-flag-icon.
-   */
-  callRemotePrefixIconRender(...args: unknown[]): Nullable<HTMLVegaFlagIconElement>;
+  private hasPrefixSlot;
+  checkPrefixSlotPresence(): void;
   render(): HTMLDivElement;
 }

package/dist/types/components/vega-input-select/vega-input-select.d.ts

@@ -56,6 +56,7 @@ export declare class VegaInputSelect {
   currentBreakpoint: BreakpointsTokenType;
   isLazyLoading: boolean;
   selectedItem: Nullable<SelectSourceItem | SelectSourceItem[]>;
+  hasPrefixSlot: boolean;
   /**
    * Specifies the label or title for the input field.
    *

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

@@ -1,4 +1,4 @@
-import { VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType, VegaRTETransformOptions } from '../../interface';
+import { VegaRTETextNode, VegaRTETextBlock, VegaRTETextBlockType, VegaRTEBlockAnnotations, VegaRTETextStyleType, VegaRTETransformOptions } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { Nullable } from '../../../../types/general';
 import { VegaRTEContent } from '../content-state';
@@ -25,6 +25,16 @@ export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock
    * @returns {RTETextBlock} A RTETextBlock class
    */
   static from(block: VegaRTETextBlock, options?: VegaRTETransformOptions): RTETextBlock;
+  /**
+   * Convert raw node payloads to their registered `RTENode` subclasses via
+   * `RTEDTOClassManager`, preserving custom types (e.g. `RTETokenNode`).
+   *
+   * @param {VegaRTETextNode[]} nodes - Raw node payloads.
+   * @param {RTETextBlock} parent - Parent block for the converted nodes.
+   * @param {VegaRTETransformOptions} [options] - Optional transform options.
+   * @returns {RTETextNode[]} Converted nodes; unregistered types are dropped.
+   */
+  protected static convertNodes(nodes: VegaRTETextNode[], parent: RTETextBlock, options?: VegaRTETransformOptions): RTETextNode[];
   /**
    * The function `createAnnotationEntity` creates a block annotation entity based on the provided type
    * and value.

package/dist/types/components/vega-segment-control/slimmers/renderers/vega-segment-renderer.d.ts

@@ -9,6 +9,7 @@ export declare class VegaSegmentRenderer extends VegaSlimmer {
   block: VegaSegmentControl['block'];
   isOverflowBlockSegments: VegaSegmentControl['isOverflowBlockSegments'];
   selectedController: VegaSegmentControl['selectedController'];
+  segmentButtonRef: VegaSegmentControl['segmentButtonRef'];
   render(props: VegaSegmentProps): HTMLElement;
   /** The below method is e2e-test covered in
    *  @see{module:vega-segment-control-set-block-e2e}

package/dist/types/components/vega-segment-control/types.d.ts

@@ -24,3 +24,5 @@ export type VegaSegmentProps = {
  * Visual variant options for the segment control component.
  */
 export type VegaSegmentControlVariant = 'icon-only' | 'text-only' | 'default';
+
+export type VegaSegmentButtonRef = (ref: HTMLButtonElement, segment: VegaSegmentProps) => void;

package/dist/types/components/vega-segment-control/vega-segment-control.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { VegaSegmentControlVariant, VegaSegmentProps } from './types';
+import { VegaSegmentButtonRef, VegaSegmentControlVariant, VegaSegmentProps } from './types';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaSegmentControlRenderer } from './slimmers/renderers/vega-segment-control-renderer';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
@@ -74,6 +74,12 @@ export declare class VegaSegmentControl {
    * @vegaVersion 2.3.0
    */
   variant: VegaSegmentControlVariant;
+  /**
+   * Callback invoked when a segment button element is rendered.
+   *
+   * @vegaVersion 2.101.0
+   */
+  segmentButtonRef: VegaSegmentButtonRef;
   /**
    * An event emitter notifying changes
    *    in the selected segment.

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

@@ -30,6 +30,23 @@ export declare class ColumnRenderInputModel {
   readonly columnIndex: number;
   readonly parent: Nullable<ColumnRenderInputModel>;
   readonly children: ColumnRenderInputModel[];
+  /**
+   * Prefix-sum pixel offset for `sticky left` positioning. Mutated by
+   * {@link VegaTableRenderInputController.recomputePinnedOffsets} on resize / column
+   * structure change. Consumed by the cell's own `render()` to emit `style.left`
+   * declaratively instead of receiving external shadow-DOM style mutation.
+   * Null when the column is not left-pinned or offsets have not yet been computed.
+   */
+  leftOffsetPx: Nullable<number>;
+  /**
+   * Prefix-sum pixel offset for `sticky right` positioning. Mirrors
+   * {@link leftOffsetPx} but for right-pinned columns.
+   */
+  rightOffsetPx: Nullable<number>;
+  isVisibleLeftEndPinned: boolean;
+  isVisibleRightStartPinned: boolean;
+  isVisibleRightEndPinned: boolean;
+  visibleColSpan: Nullable<number>;
   private iteratorCacheMap;
   private leaves;
   /**

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

@@ -0,0 +1,39 @@
+import { ColumnStructureModel } from './column-structure-model';
+import { ColumnRenderInputModel } from './column-render-input-model';
+export declare type RowKind = 'head' | 'body' | 'foot' | 'expand';
+export declare type TableRowStructure = {
+  hasExpandableRow: boolean;
+  paddingX: [string, string];
+  rowDraggable: boolean;
+  rowExpandable: unknown;
+  rowSelection: {
+    type?: string;
+  } | null;
+};
+/** Render-time structural state shared by table row variants. */
+export declare class RowRenderInputModel {
+  readonly kind: RowKind;
+  readonly hasLeftPinnedColumn: boolean;
+  readonly hasRightPinnedColumn: boolean;
+  readonly showSelectionCell: boolean;
+  readonly showDraggableCell: boolean;
+  readonly showExpandActionCell: boolean;
+  readonly hasExpandedRowSlot: boolean;
+  readonly leftPaddingPx: number;
+  readonly rightPaddingPx: number;
+  readonly startRowSpan: number;
+  readonly endRowSpan: number;
+  readonly isStartHidden: boolean;
+  readonly isEndHidden: boolean;
+  constructor(kind: RowKind, hasLeftPinnedColumn: boolean, hasRightPinnedColumn: boolean, showSelectionCell: boolean, showDraggableCell: boolean, showExpandActionCell: boolean, hasExpandedRowSlot: boolean, leftPaddingPx: number, rightPaddingPx: number, startRowSpan?: number, endRowSpan?: number, isStartHidden?: boolean, isEndHidden?: boolean);
+  /**
+   * Create row render input from table and column structure state.
+   *
+   * @param {ColumnStructureModel} structure - Current column structure.
+   * @param {TableRowStructure} table - Current row-related table state.
+   * @param {RowKind} kind - Row variant being rendered.
+   * @param {ColumnRenderInputModel[]} headRenderInputs - Header columns for row-span metadata.
+   * @returns {RowRenderInputModel} Row-owned render input.
+   */
+  static from(structure: ColumnStructureModel, table: TableRowStructure, kind: RowKind, headRenderInputs?: ColumnRenderInputModel[]): RowRenderInputModel;
+}

package/dist/types/components/vega-table/slimmers/controllers/vega-table-render-input-controller.d.ts

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
 import { ColumnRenderInputModel } from './dto/column-render-input-model';
+import { RowKind } from './dto/row-render-input-model';
 /**
  * VegaTableRenderInputController
  *
@@ -13,11 +14,20 @@ import { ColumnRenderInputModel } from './dto/column-render-input-model';
 export declare class VegaTableRenderInputController extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
+  paddingX: VegaTable['paddingX'];
+  rowDraggable: VegaTable['rowDraggable'];
+  rowExpandable: VegaTable['rowExpandable'];
+  rowSelection: VegaTable['rowSelection'];
+  isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
   private columnRenderInputModels;
   private leavesRenderInputModels;
   private headRowRenderInputMap;
   private headCellRenderInputMap;
-  private pinnedColumnBodyCellRenderInputMap;
+  private bodyCellRenderInputMap;
+  private hasPendingCellRenderInputChange;
+  private rowRenderInputMap;
+  private footCellRenderInputMap;
   private cellRenderInputChangeTaskQueue;
   /**
    * Register remote invocation observers when controller is connected.
@@ -36,7 +46,7 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
   componentWillLoad(): void;
   /**
    * Notify body cells about render input changes after the table has re-rendered.
-   * This ensures ref callbacks have fired and the pinnedColumnBodyCellRenderInputMap is up-to-date.
+   * This ensures ref callbacks have fired and the body-cell render inputs are up-to-date.
    * Called via component lifecycle mapping.
    */
   componentDidRender(): Promise<void>;
@@ -45,6 +55,8 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * Called via watch mapping.
    */
   watchColumnStructureModel(): Promise<void>;
+  /** Clear cached row inputs when row-related table state changes. */
+  watchRowStructure(): void;
   /**
    * Return render input models for table body (flattened leaves).
    *
@@ -80,14 +92,19 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    */
   clearHeadRenderInputMaps(): void;
   /**
-   * Store body cell render input mapping for pinned cells (used to update sticky positions).
-   *
-   * Only stores cells that require sticky positioning (left/right or no-pinned-end).
+   * Store body cell render input mapping without retaining disconnected cell hosts.
    *
    * @param {HTMLElement} cell - The body cell element.
    * @param {ColumnRenderInputModel} renderInput - Associated render input model.
    */
   addCellRenderInputMap(cell: HTMLVegaTableCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Store row render input mapping for remote invocation.
+   *
+   * @param {HTMLElement} row - Row host element.
+   * @param {RowKind} kind - Row variant.
+   */
+  addRowRenderInputMap(row: HTMLElement, kind: RowKind): void;
   /**
    * Expose the internal head-cell -> render-input mapping.
    *
@@ -96,12 +113,32 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    */
   getHeadCellRenderInputMap(): Map<HTMLVegaTableHeadCellElement, ColumnRenderInputModel>;
   /**
-   * Expose the internal map of pinned body cells to their render inputs.
+   * Return a snapshot of currently rendered body cells and their render inputs.
    *
    * @typedef {import('../../../../types/components').HTMLVegaTableCellElement} HTMLVegaTableCellElement
-   * @returns {Map<HTMLVegaTableCellElement, ColumnRenderInputModel>} Map of body cell hosts requiring sticky positioning.
+   * @returns {Map<HTMLVegaTableCellElement, ColumnRenderInputModel>} Current body-cell render inputs.
    */
   getPinnedColumnBodyCellRenderInputMap(): Map<HTMLVegaTableCellElement, ColumnRenderInputModel>;
+  /**
+   * Recompute per-column sticky pinned offsets (`leftOffsetPx` / `rightOffsetPx`) on
+   * every registered head, body, and foot cell render input,
+   * then notify subscribers so pinned cells re-render with the new offsets.
+   *
+   * This is the write-side of the declarative pinned pipeline described in VD-9881:
+   * instead of {@link VegaTablePinnedRenderer} mutating each cell's shadow-DOM
+   * `style.left`/`style.right`, the controller populates the offset on the DTO and
+   * pinned cells consume it from their own `render()` via a JSX `style` prop.
+   *
+   * Idempotent — safe to call multiple times per lifecycle event. Measurement of
+   * `prevShadowThWidth`, `nextShadowThWidth`, and `leafWidths` lives with the pinned
+   * renderer (it needs those values for other passes too — breakpoint-hidden column
+   * detection, template-mode leaf zipping, etc.) and is supplied by the caller.
+   *
+   * @param {number} prevShadowThWidth - Aggregate width of leading row-fixed cells (left padding).
+   * @param {number} nextShadowThWidth - Aggregate width of trailing row-fixed cells (right padding).
+   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
+   */
+  recomputePinnedOffsets(prevShadowThWidth: number, nextShadowThWidth: number, leafWidths: number[]): void;
   /**
    * Register remote invocation callbacks to allow DOM nodes to request render inputs.
    */
@@ -110,6 +147,33 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * Unregister remote invocation callbacks previously registered.
    */
   private unRegisterRenderInputRICObserver;
+  /** Register authored template rows and cells with their render inputs. */
+  private registerTemplateCellRenderInputs;
+  /**
+   * Compare the structural fields that determine a cell render input.
+   *
+   * @param {ColumnRenderInputModel} current - Existing render input.
+   * @param {ColumnRenderInputModel} candidate - Newly computed render input.
+   * @returns {boolean} Whether the structural fields match.
+   */
+  private hasSameCellStructure;
+  /** Notify consumers that table render inputs changed. */
+  private notifyRenderInputChange;
+  /**
+   * Create and cache render input for a requesting row.
+   *
+   * @param {HTMLElement} row - Requesting row host.
+   * @returns {RowRenderInputModel} Cached row render input.
+   */
+  private createRowRenderInput;
+  /**
+   * Build row render input from current table state.
+   *
+   * @param {RowKind} kind - Row variant.
+   * @param {HTMLElement} row - Row host used for header metadata lookup.
+   * @returns {RowRenderInputModel} Current row render input.
+   */
+  private createRowRenderInputModel;
   /**
    * Build the ColumnRenderInputModel forest from the current ColumnStructureModel.
    */

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

@@ -13,6 +13,7 @@ export declare class VegaTableBodyRenderer extends VegaSlimmer {
   vegaTableRowRenderer: VegaTable['vegaTableRowRenderer'];
   columnStructureModel: VegaTable['columnStructureModel'];
   vegaTableExpandRowController: VegaTable['vegaTableExpandRowController'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   private tableFormRef;
   private tableBodyRef;
   getTableFormRef(): Nullable<HTMLVegaFormElement>;

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

@@ -4,99 +4,14 @@ import { PageResizeObserverSlimmer } from '../../../../helpers/slimmers/page-res
 export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
-  paddingX: VegaTable['paddingX'];
   isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
-  private previouslyStyledCells;
-  private dynamicRightDividerCells;
-  private dynamicLeftDividerCells;
-  private dynamicHideRightBorderCells;
-  private templateColspanSyncedCells;
-  private clearPinnedPositionsTaskQueue;
   componentDidLoad(): void;
-  componentDidRender(): Promise<void>;
+  componentDidRender(): void;
   watchColumnStructureModel(): void;
-  private updateTableCellPinnedPosition;
-  /**
-   * Resolve the DOM root that holds the table rows.
-   *
-   * In data-source mode rows are rendered into the table's shadow root; in template mode the
-   * authored rows are slotted, so they live in the host's light DOM.
-   *
-   * @returns {ShadowRoot | HTMLElement} The container to query rows from.
-   */
+  private recomputeRenderInputs;
   private getRowContainerRoot;
-  /**
-   * Position authored template body and foot leaf cells by zipping them with the leaf render
-   * inputs in authored order, advancing by each cell's colSpan. Also applies the pinned-boundary
-   * divider classes (mirroring the body cell's render()), since authored body/foot cells have no
-   * render-input of their own in template mode.
-   *
-   * @param {number} prevShadowThWidth - Aggregate width of leading fixed columns (table left padding).
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {number} nextShadowThWidth - Aggregate width of trailing fixed columns (table right padding).
-   */
-  private updateTemplateLeafCellPinnedPosition;
-  /**
-   * Record an authored template leaf cell's shadow cell as the last visible left-pinned / first &
-   * last visible right-pinned cell of its row, so the shared dynamic-boundary logic can shift the
-   * boundary divider onto it when the static boundary column is breakpoint-hidden.
-   *
-   * @param {HTMLElement} row - The authored body or foot row (used as the per-row grouping key).
-   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
-   * @param {Map<HTMLElement, HTMLElement>} lastVisibleLeftPinnedBodyCells - Per-row last visible left-pinned shadow cell.
-   * @param {Map<HTMLElement, HTMLElement>} firstVisibleRightPinnedBodyCells - Per-row first visible right-pinned shadow cell.
-   * @param {Map<HTMLElement, HTMLElement>} lastVisibleRightPinnedBodyCells - Per-row last visible right-pinned shadow cell.
-   */
-  private trackVisiblePinnedTemplateCell;
-  /**
-   * Reduce an authored template pinned cell's shadow <td> colspan to the number of *visible*
-   * columns it spans. Breakpoint-hidden columns report width 0 but Chrome still counts them in the
-   * table grid, so without this a pinned span drifts out of column-alignment with the header
-   * (VD-9540). Only applies to pinned cells; skipped off-screen / in jsdom where every width is 0.
-   *
-   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
-   * @param {number} colSpan - The cell's originally declared colspan.
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {boolean} allLeafWidthsHidden - True when every leaf width is 0 (off-screen / jsdom).
-   */
-  private syncTemplateLeafColspan;
-  /**
-   * Restore the authored colspan on every template cell whose shadow <td> was shrunk by
-   * {@link syncTemplateLeafColspan}. Runs on cleanup so removing `pinned` at runtime does not leave
-   * a body/foot cell stuck at the breakpoint-shrunk colspan once positioning no longer runs (VD-9768).
-   */
-  private restoreTemplateLeafColspan;
-  /**
-   * Apply the pinned-boundary divider classes to an authored template body/foot cell's shadow
-   * cell, merging boundary flags across the leaves the cell spans. Tracked in the dynamic sets so
-   * the next positioning pass clears and re-evaluates them (matching the data-source cleanup path).
-   *
-   * @param {HTMLVegaTableCellElement} cell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel[]} spannedLeaves - Leaf render inputs the cell spans.
-   */
-  private applyTemplateLeafDividerClass;
-  private getRowShadowThWidths;
+  private getRowFixedWidths;
   private getLeafWidths;
-  private syncColspanForHiddenColumns;
-  /**
-   * Count how many columns in a span are actually visible (leaf width > 0). Breakpoint-hidden
-   * columns report width 0 because their <th> is display:none; Chrome ignores that on the table
-   * grid, so a spanning cell's shadow <td> colspan must be reduced to the visible count to stay
-   * column-aligned (VD-9540). Shared by data-source and template positioning paths.
-   *
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {number} startIndex - columnIndex of the first leaf the spanning cell covers.
-   * @param {number} declaredColspan - The cell's originally declared colspan.
-   * @returns {number} The number of visible columns in the span (>= 1).
-   */
-  private countVisibleColspan;
-  private resolveCellColSpan;
-  private updateCellPinnedPosition;
-  private updateTableRowPinnedPosition;
-  private clearAllPinnedPositions;
-  private updatePinnedPosition;
 }

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

@@ -1,11 +1,11 @@
 import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTableExpandRow } from '../../vega-table-expand-row';
 export declare class VegaTableExpandRowRenderer extends VegaSlimmer {
-  host: VegaTableExpandRow['host'];
   rowKey: VegaTableExpandRow['rowKey'];
   expanded: VegaTableExpandRow['expanded'];
   checked: VegaTableExpandRow['checked'];
   colSpan: VegaTableExpandRow['colSpan'];
   striped: VegaTableExpandRow['striped'];
+  renderInput: VegaTableExpandRow['renderInput'];
   render(): HTMLTableRowElement;
 }

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

@@ -7,6 +7,9 @@ import { BreakpointsTokenType } from '../../../types/design-token.type';
 import { VegaTableExpandRowColSpanController } from './slimmers/controllers/vega-table-expand-row-col-span-controller';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
+import { RowRenderInputModel } from '../slimmers/controllers/dto/row-render-input-model';
+import { Nullable } from '../../../types/general';
 /**
  * @vegaVersion 1.44.0
  */
@@ -18,9 +21,11 @@ export declare class VegaTableExpandRow {
   protected readonly vegaTableExpandRowStateController: VegaTableExpandRowStateController;
   protected readonly vegaTableExpandRowColSpanController: VegaTableExpandRowColSpanController;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableExpandRowElement>;
   host: HTMLVegaTableExpandRowElement;
   currentBreakpoint: BreakpointsTokenType;
+  renderInput: Nullable<RowRenderInputModel>;
   watchCurrentBreakpoint(): void;
   /**
    * Whether the expandable host row has multiple selection checkbox.

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

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