@globalpayments/vega 2.99.0 → 2.101.0

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

@@ -8,10 +8,24 @@ export declare class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSli
   private linkEditorRef;
   private currentSelectedText;
   private linkBtnWrapperRef;
+  private escapePressedDuringPopover;
+  private documentKeydownRegistered;
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   *
+   * Removes the document-level Escape listener registered in the wrapper
+   * ref callback so the slimmer instance is not retained by document after
+   * the rich-text editor is destroyed.
+   */
+  disconnectedCallback(): void;
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton?: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   protected onClick(): void;
   private handleLinkEditorChange;
+  private handleWrapperClickCapture;
+  private handlePopoverShow;
+  private handleDocumentKeydown;
+  private handlePopoverHide;
 }

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

@@ -2,7 +2,6 @@ import { ToolbarButtonSlimmer } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   sourceView: VegaRichTextEditor['sourceView'];
-  selectionController: VegaRichTextEditor['selectionController'];
   valueController: VegaRichTextEditor['valueController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
@@ -10,6 +9,9 @@ export declare class SourceEditToolbarButtonSlimmer extends ToolbarButtonSlimmer
   value: VegaRichTextEditor['value'];
   constructor();
   protected onClick(): Promise<void>;
+  protected preventLostFocus(): {
+    onMouseDown?: (e: Event) => void;
+  };
   protected isSelected(): boolean;
   protected isDisabled(): boolean;
   private saveSourceCode;

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

@@ -13,8 +13,9 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
   protected readonly disabled: VegaRichTextEditor['disabled'];
   private icon;
   private readonly tooltip;
+  private readonly ariaLabel;
   private readonly autoFocusOnClick;
-  protected constructor({ icon, tooltip, autoFocusOnClick }: ToolbarButtonConfig);
+  protected constructor({ icon, tooltip, ariaLabel, autoFocusOnClick }: ToolbarButtonConfig);
   setIcon(icon: string): void;
   /**
    * Whether the button is hidden or not.
@@ -41,7 +42,7 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
    */
   protected isDisabled(): boolean;
   protected preventLostFocus(): {
-    onMouseDown: (e: Event) => void;
+    onMouseDown?: (e: Event) => void;
   };
   private renderBtn;
   /**

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

@@ -17,6 +17,7 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
   sourceEditConfig: VegaRichTextEditor['sourceEditConfig'];
   allowSourceEdit: VegaRichTextEditor['allowSourceEdit'];
   extensions: VegaRichTextEditor['extensions'];
+  wordCountController: VegaRichTextEditor['wordCountController'];
   richTextEditorSourceViewRenderer: VegaRichTextEditor['richTextEditorSourceViewRenderer'];
   private richTextContainerRef;
   private richTextContentRef;
@@ -49,6 +50,17 @@ export declare class VegaRichTextEditorRenderer extends VegaSlimmer {
    * @returns {Nullable<HTMLDivElement>} The div element which has property contenteditable
    */
   getRTEEditableElementRef(): Nullable<HTMLDivElement>;
+  /**
+   * Re-injects the zero-width space placeholder into empty text spans.
+   * When a commit is rejected and the model rolls back unchanged, the framework
+   * short-circuits the text diff and leaves the span empty, collapsing the line
+   * height, so the placeholder is restored here.
+   */
+  restoreEmptyTextPlaceholders(): void;
+  /**
+   * Forces a re-render of the rich text content component, which is useful when the content has changed but the framework has not detected it.
+   */
+  forceContentRepaint(): void;
   render(): VegaRichTextEditor;
   private renderRichTextEditor;
   private renderLabel;

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

@@ -5,6 +5,7 @@ import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/ev
 import { VegaRichTextEditorToolbarButtonRenderer } from './slimmers/renderers/vega-rich-text-editor-toolbar-button-renderer';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { TextColorsTokenType } from '../../../types/design-token.type';
+import { AriaAttributesValueMapper } from '../../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
 + * @vegaVersion 2.34.0
 + */
@@ -14,6 +15,7 @@ export declare class VegaRichTextEditorToolbarButton {
   protected clickEventEmitter: EventEmitSlimmerBase;
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly renderer: VegaRichTextEditorToolbarButtonRenderer;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   host: HTMLVegaRichTextEditorToolbarButtonElement;
   /**
    * Specifies whether the rich text editor toolbar button element is disabled.

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

@@ -45,7 +45,9 @@ import { InternalCodeBlockSelectionController } from './slimmers/controllers/int
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
 import { VegaRTEExtension } from './extensions/extension.abstract';
 import { RTEExtensionController } from './slimmers/controllers/extension-controller';
+import { WordCountController } from './slimmers/controllers/word-count-controller';
 import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-rich-text-editor-source-view-renderer';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 /**
  * The rich text editor enables users to format text for a variety of publishers.
  *
@@ -53,6 +55,7 @@ import { VegaRichTextEditorSourceViewRenderer } from './slimmers/renderers/vega-
  */
 export declare class VegaRichTextEditor {
   protected readonly globalSlimmers: GlobalSlimmers;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected translationSlimmer: TranslationSlimmer<HTMLVegaRichTextEditorElement>;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaRichTextEditorElement>;
   protected formFieldController: FormFieldControllerSlimmer<VegaRTEContentBlock[]>;
@@ -93,6 +96,7 @@ export declare class VegaRichTextEditor {
   protected readonly historyController: HistoryController;
   protected readonly internalCodeBlockSelectionController: InternalCodeBlockSelectionController;
   protected readonly rteExtensionController: RTEExtensionController;
+  protected readonly wordCountController: WordCountController;
   protected readonly sourceCodeChangeEventEmitter: EventEmitSlimmerBase;
   protected readonly richTextEditorSourceViewRenderer: VegaRichTextEditorSourceViewRenderer;
   host: HTMLVegaRichTextEditorElement;

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

@@ -16,6 +16,22 @@ export declare class LinkEditorController extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private readonly linkUrlNormalizer;
   private readonly linkTypeHandlers;
+  /**
+   * The element the trigger click listener is currently attached to (the link
+   * wrapper acting as the popover target).
+   */
+  private triggerListenerEl;
+  /**
+   * Whether the popover was opened via a keyboard or screen-reader (VoiceOver)
+   * activation. When true, focus is moved into the popover so screen reader
+   * users land on the Edit button.
+   */
+  private isVoiceOverTrigger;
+  /**
+   * The element that had focus when the VoiceOver activation happened, so focus
+   * can be restored to the link once the popover is hidden.
+   */
+  private focusReturnEl;
   /** Initializes the popover target after the component loads. */
   componentDidLoad(): void;
   /** Notifies observers after each render cycle. */
@@ -88,6 +104,58 @@ export declare class LinkEditorController extends VegaSlimmer {
    * @returns {void} No return value.
    */
   private updatePopoverTarget;
+  /**
+   * Attaches a capture-phase click listener to the link wrapper (the popover
+   * target) so a keyboard/VoiceOver activation can be distinguished from a real
+   * pointer click before the popover opens. Re-attaches when the target changes.
+   *
+   * @returns {void} No return value.
+   */
+  private attachTriggerListener;
+  /**
+   * Removes the trigger listener from the previously observed element.
+   *
+   * @returns {void} No return value.
+   */
+  private detachTriggerListener;
+  /**
+   * Records whether the popover was opened via a keyboard/VoiceOver activation
+   * and, if so, the element to restore focus to when the popover closes.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {void} No return value.
+   */
+  private readonly handleTriggerClick;
+  /**
+   * Determines whether a click on the link wrapper came from a keyboard or
+   * screen reader (VoiceOver) rather than a real pointer.
+   *
+   * A genuine pointer click lands inside the activated element. Keyboard (Enter,
+   * `detail === 0`) and VoiceOver activations dispatch a click with coordinates
+   * that are not on the element, so we treat any click whose point falls outside
+   * the wrapper as an assistive-technology activation.
+   *
+   * @param {MouseEvent} e - The click event on the link wrapper.
+   * @returns {boolean} True when the activation is keyboard/screen-reader driven.
+   */
+  private isKeyboardOrScreenReaderActivation;
+  /**
+   * Moves focus to the first focusable element within the popover content (the
+   * Edit button) so VoiceOver users land inside the opened toolbar.
+   *
+   * Deferred to the next macrotask so it runs after the editor has finished
+   * placing the caret/focus into the content area on the activating click.
+   *
+   * @returns {void} No return value.
+   */
+  private focusPopoverContentForVoiceOver;
+  /**
+   * Restores focus to the link wrapper after the popover is hidden following a
+   * VoiceOver activation.
+   *
+   * @returns {void} No return value.
+   */
+  private restoreFocusAfterVoiceOver;
   /**
    * Preserves an unchanged mailto URL when the form edits are equivalent.
    *

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

@@ -10,9 +10,11 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   protected linkEditorStateManager: VegaRichTextLinkEditor['linkEditorStateManager'];
   private formRef;
   private popoverRef;
+  private popoverContentRef;
   private urlInputRef;
   private textInputRef;
   getPopoverRef(): HTMLVegaPopoverElement;
+  getPopoverContentRef(): Nullable<HTMLElement>;
   getFormRef(): Nullable<HTMLVegaFormElement>;
   getUrlInputRef(): Nullable<HTMLVegaInputElement>;
   getTextInputRef(): Nullable<HTMLVegaInputElement>;
@@ -28,6 +30,7 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   private readonly handlePopoverRef;
   private readonly handleButtonGroupRef;
   private readonly handleFormRef;
+  private readonly handlePopoverContentRef;
   private readonly handleUrlInputRef;
   private readonly handleTextInputRef;
   private readonly handleLinkFieldKeyDown;

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