@heartlandone/vega 2.100.0 → 2.102.0

package/dist/collection/components/vega-table/slimmers/controllers/vega-table-render-input-controller.js

@@ -6,11 +6,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
 import domNodeSubjectFactory from '../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
-import { VegaInternalVegaTableRenderInputChange, VegaInternalColumnBodyCellRenderInputRIC, VegaInternalColumnHeadCellRenderInputRIC, VegaInternalColumnHeadRowRenderInputRIC, } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import { VegaInternalVegaTableRenderInputChange, VegaInternalColumnBodyCellRenderInputRIC, VegaInternalColumnHeadCellRenderInputRIC, VegaInternalColumnHeadRowRenderInputRIC, VegaInternalRowRenderInputRIC, VegaInternalColumnFootCellRenderInputRIC, VegaInternalColumnExpandCellRenderInputRIC, } from '../../../../helpers/event-manager/event-id/vega-internal-event-id';
 import remoteInvocationRegistry from '../../../../helpers/remote-invocation/remote-invocation-registry';
 import changeManager from '../../../../helpers/change-manager/change-manager';
 import { SynchronizeTaskQueue } from '../../../../helpers/queue/synchronize-task-queue';
 import { ColumnRenderInputModel } from './dto/column-render-input-model';
+import { RowRenderInputModel } from './dto/row-render-input-model';
 /**
  * VegaTableRenderInputController
  *
@@ -23,9 +24,12 @@ import { ColumnRenderInputModel } from './dto/column-render-input-model';
 export class VegaTableRenderInputController extends VegaSlimmer {
   constructor() {
     super(...arguments);
-    this.headRowRenderInputMap = new Map();
-    this.headCellRenderInputMap = new Map();
-    this.pinnedColumnBodyCellRenderInputMap = new Map();
+    this.headRowRenderInputMap = new WeakMap();
+    this.headCellRenderInputMap = new WeakMap();
+    this.bodyCellRenderInputMap = new WeakMap();
+    this.hasPendingCellRenderInputChange = false;
+    this.rowRenderInputMap = new WeakMap();
+    this.footCellRenderInputMap = new Map();
     this.cellRenderInputChangeTaskQueue = new SynchronizeTaskQueue();
   }
   /**
@@ -51,10 +55,19 @@ export class VegaTableRenderInputController extends VegaSlimmer {
   }
   /**
    * 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.
    */
   async componentDidRender() {
+    if (this.isTemplateRenderMode) {
+      this.registerTemplateCellRenderInputs();
+      if (this.hasPendingCellRenderInputChange &&
+        !this.columnStructureModel.hasLeftPinnedColumn() &&
+        !this.columnStructureModel.hasRightPinnedColumn()) {
+        this.notifyRenderInputChange();
+        this.hasPendingCellRenderInputChange = false;
+      }
+    }
     await this.cellRenderInputChangeTaskQueue.runTask();
   }
   /**
@@ -63,7 +76,7 @@ export class VegaTableRenderInputController extends VegaSlimmer {
    */
   async watchColumnStructureModel() {
     this.setRenderInputModel();
-    this.pinnedColumnBodyCellRenderInputMap.clear();
+    this.bodyCellRenderInputMap = new WeakMap();
     await this.cellRenderInputChangeTaskQueue.enqueue({
       /**
        * Notify body-cell render-input changes after render completes.
@@ -73,6 +86,11 @@ export class VegaTableRenderInputController extends VegaSlimmer {
       },
     }, false);
   }
+  /** Clear cached row inputs when row-related table state changes. */
+  watchRowStructure() {
+    this.rowRenderInputMap = new WeakMap();
+    changeManager.notify(domNodeSubjectFactory.getSubject(this.host, VegaInternalVegaTableRenderInputChange), {});
+  }
   /**
    * Return render input models for table body (flattened leaves).
    *
@@ -96,6 +114,8 @@ export class VegaTableRenderInputController extends VegaSlimmer {
    * @param {ColumnRenderInputModel[]} renderInputs - Associated render input models.
    */
   addHeadRowRenderInputMap(headRow, renderInputs) {
+    if (!headRow)
+      return;
     this.headRowRenderInputMap.set(headRow, renderInputs);
   }
   /**
@@ -105,6 +125,8 @@ export class VegaTableRenderInputController extends VegaSlimmer {
    * @param {ColumnRenderInputModel} renderInput - Associated render input model.
    */
   addHeadCellRenderInputMap(headCell, renderInput) {
+    if (!headCell)
+      return;
     this.headCellRenderInputMap.set(headCell, renderInput);
   }
   /**
@@ -115,21 +137,37 @@ export class VegaTableRenderInputController extends VegaSlimmer {
    * re-registers via ref callbacks each render, so stale entries are overwritten naturally.
    */
   clearHeadRenderInputMaps() {
-    this.headRowRenderInputMap.clear();
-    this.headCellRenderInputMap.clear();
+    this.headRowRenderInputMap = new WeakMap();
+    this.headCellRenderInputMap = new WeakMap();
   }
   /**
-   * 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, renderInput) {
-    if ((cell && ['left', 'right'].includes(renderInput.pinned)) || renderInput.isNoPinnedEnd) {
-      this.pinnedColumnBodyCellRenderInputMap.set(cell, renderInput);
+    if (!cell)
+      return;
+    const current = this.bodyCellRenderInputMap.get(cell);
+    const next = this.hasSameCellStructure(current, renderInput)
+      ? current
+      : renderInput;
+    if (current !== next) {
+      this.hasPendingCellRenderInputChange = true;
     }
+    this.bodyCellRenderInputMap.set(cell, next);
+  }
+  /**
+   * Store row render input mapping for remote invocation.
+   *
+   * @param {HTMLElement} row - Row host element.
+   * @param {RowKind} kind - Row variant.
+   */
+  addRowRenderInputMap(row, kind) {
+    if (!row)
+      return;
+    this.rowRenderInputMap.set(row, this.createRowRenderInputModel(kind, row));
   }
   /**
    * Expose the internal head-cell -> render-input mapping.
@@ -138,16 +176,133 @@ export class VegaTableRenderInputController extends VegaSlimmer {
    * @returns {Map<HTMLVegaTableHeadCellElement, ColumnRenderInputModel>} Map of head cell elements to render input.
    */
   getHeadCellRenderInputMap() {
-    return this.headCellRenderInputMap;
+    var _a;
+    const renderInputMap = new Map();
+    const root = this.isTemplateRenderMode ? this.host : (_a = this.host) === null || _a === void 0 ? void 0 : _a.shadowRoot;
+    root === null || root === void 0 ? void 0 : root.querySelectorAll('vega-table-head-cell').forEach((cell) => {
+      const renderInput = this.headCellRenderInputMap.get(cell);
+      if (renderInput)
+        renderInputMap.set(cell, renderInput);
+    });
+    return renderInputMap;
   }
   /**
-   * 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() {
-    return this.pinnedColumnBodyCellRenderInputMap;
+    var _a;
+    const renderInputMap = new Map();
+    const root = this.isTemplateRenderMode ? this.host : (_a = this.host) === null || _a === void 0 ? void 0 : _a.shadowRoot;
+    root === null || root === void 0 ? void 0 : root.querySelectorAll('vega-table-cell').forEach((cell) => {
+      const renderInput = this.bodyCellRenderInputMap.get(cell);
+      if (renderInput)
+        renderInputMap.set(cell, renderInput);
+    });
+    return renderInputMap;
+  }
+  /**
+   * 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, nextShadowThWidth, leafWidths) {
+    var _a, _b, _c;
+    const headCellRenderInputMap = this.getHeadCellRenderInputMap();
+    if (!headCellRenderInputMap.size)
+      return;
+    this.registerTemplateCellRenderInputs();
+    const leafPrefixLeft = new Array(leafWidths.length + 1).fill(0);
+    for (let i = 0; i < leafWidths.length; i++) {
+      leafPrefixLeft[i + 1] = leafPrefixLeft[i] + leafWidths[i];
+    }
+    const allLeafWidthsHidden = leafWidths.every((width) => width === 0);
+    const visibleLeftPinned = this.leavesRenderInputModels.filter((model) => model.pinned === 'left' && (allLeafWidthsHidden || leafWidths[model.columnIndex] > 0));
+    const visibleRightPinned = this.leavesRenderInputModels.filter((model) => model.pinned === 'right' && (allLeafWidthsHidden || leafWidths[model.columnIndex] > 0));
+    const visibleLeftEndIndex = (_a = visibleLeftPinned[visibleLeftPinned.length - 1]) === null || _a === void 0 ? void 0 : _a.columnIndex;
+    const visibleRightStartIndex = (_b = visibleRightPinned[0]) === null || _b === void 0 ? void 0 : _b.columnIndex;
+    const visibleRightEndIndex = (_c = visibleRightPinned[visibleRightPinned.length - 1]) === null || _c === void 0 ? void 0 : _c.columnIndex;
+    let hasRenderInputChange = this.hasPendingCellRenderInputChange;
+    /**
+     * Apply cell-owned visible boundaries and sticky offsets.
+     *
+     * @param {ColumnRenderInputModel} renderInput - Cell render input to update.
+     * @param {HTMLElement} cell - Cell host supplying its effective colspan.
+     * @returns {boolean} Whether the render input changed.
+     */
+    const setOffsets = (renderInput, cell) => {
+      var _a;
+      const colSpan = (_a = renderInput.colSpan) !== null && _a !== void 0 ? _a : (cell.colSpan || 1);
+      /**
+       * Check whether the current cell spans a leaf index.
+       *
+       * @param {number} index - Leaf index to test.
+       * @returns {boolean} Whether the cell includes the index.
+       */
+      const spansIndex = (index) => Number.isInteger(index) &&
+        index >= renderInput.columnIndex &&
+        index < renderInput.columnIndex + colSpan;
+      const isVisibleLeftEndPinned = spansIndex(visibleLeftEndIndex);
+      const isVisibleRightStartPinned = spansIndex(visibleRightStartIndex);
+      const isVisibleRightEndPinned = spansIndex(visibleRightEndIndex);
+      const visibleColSpan = colSpan > 1 && !allLeafWidthsHidden
+        ? Math.max(1, leafWidths
+          .slice(renderInput.columnIndex, renderInput.columnIndex + colSpan)
+          .filter((width) => width > 0).length)
+        : null;
+      let leftOffsetPx = null;
+      let rightOffsetPx = null;
+      if (renderInput.pinned === 'left') {
+        leftOffsetPx = prevShadowThWidth + leafPrefixLeft[renderInput.columnIndex];
+      }
+      else if (renderInput.pinned === 'right') {
+        const endIndex = renderInput.columnIndex + colSpan;
+        rightOffsetPx =
+          nextShadowThWidth + (leafPrefixLeft[leafWidths.length] - leafPrefixLeft[endIndex]);
+      }
+      const changed = renderInput.isVisibleLeftEndPinned !== isVisibleLeftEndPinned ||
+        renderInput.isVisibleRightStartPinned !== isVisibleRightStartPinned ||
+        renderInput.isVisibleRightEndPinned !== isVisibleRightEndPinned ||
+        renderInput.visibleColSpan !== visibleColSpan ||
+        renderInput.leftOffsetPx !== leftOffsetPx ||
+        renderInput.rightOffsetPx !== rightOffsetPx;
+      renderInput.isVisibleLeftEndPinned = isVisibleLeftEndPinned;
+      renderInput.isVisibleRightStartPinned = isVisibleRightStartPinned;
+      renderInput.isVisibleRightEndPinned = isVisibleRightEndPinned;
+      renderInput.visibleColSpan = visibleColSpan;
+      renderInput.leftOffsetPx = leftOffsetPx;
+      renderInput.rightOffsetPx = rightOffsetPx;
+      return changed;
+    };
+    headCellRenderInputMap.forEach((renderInput, cell) => {
+      hasRenderInputChange = setOffsets(renderInput, cell) || hasRenderInputChange;
+    });
+    this.getPinnedColumnBodyCellRenderInputMap().forEach((renderInput, cell) => {
+      hasRenderInputChange = setOffsets(renderInput, cell) || hasRenderInputChange;
+    });
+    this.footCellRenderInputMap.forEach((renderInput, cell) => {
+      hasRenderInputChange = setOffsets(renderInput, cell) || hasRenderInputChange;
+    });
+    this.hasPendingCellRenderInputChange = false;
+    if (hasRenderInputChange) {
+      this.notifyRenderInputChange();
+    }
   }
   /**
    * Register remote invocation callbacks to allow DOM nodes to request render inputs.
@@ -160,7 +315,18 @@ export class VegaTableRenderInputController extends VegaSlimmer {
       return this.headCellRenderInputMap.get(headCell);
     });
     remoteInvocationRegistry.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnBodyCellRenderInputRIC), (cell) => {
-      return this.pinnedColumnBodyCellRenderInputMap.get(cell);
+      return this.bodyCellRenderInputMap.get(cell);
+    });
+    remoteInvocationRegistry.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalRowRenderInputRIC), (row) => {
+      var _a;
+      return (_a = this.rowRenderInputMap.get(row)) !== null && _a !== void 0 ? _a : this.createRowRenderInput(row);
+    });
+    remoteInvocationRegistry.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnExpandCellRenderInputRIC), (row) => {
+      var _a;
+      return (_a = this.rowRenderInputMap.get(row)) !== null && _a !== void 0 ? _a : this.createRowRenderInput(row);
+    });
+    remoteInvocationRegistry.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnFootCellRenderInputRIC), (cell) => {
+      return this.footCellRenderInputMap.get(cell);
     });
   }
   /**
@@ -170,11 +336,118 @@ export class VegaTableRenderInputController extends VegaSlimmer {
     remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnHeadRowRenderInputRIC));
     remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnHeadCellRenderInputRIC));
     remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnBodyCellRenderInputRIC));
+    remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalRowRenderInputRIC));
+    remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnExpandCellRenderInputRIC));
+    remoteInvocationRegistry.unRegister(domNodeSubjectFactory.getSubject(this.host, VegaInternalColumnFootCellRenderInputRIC));
+  }
+  /** Register authored template rows and cells with their render inputs. */
+  registerTemplateCellRenderInputs() {
+    const rows = this.host.querySelectorAll('vega-table-row, vega-table-foot-row');
+    if (!rows.length) {
+      if (this.footCellRenderInputMap.size)
+        this.hasPendingCellRenderInputChange = true;
+      this.footCellRenderInputMap = new Map();
+      return;
+    }
+    const nextFootCellRenderInputMap = new Map();
+    rows.forEach((row) => {
+      this.addRowRenderInputMap(row, row.matches('vega-table-foot-row') ? 'foot' : 'body');
+      let leafIndex = 0;
+      Array.from(row.children).forEach((cell) => {
+        if (cell.tagName !== 'VEGA-TABLE-CELL' && cell.tagName !== 'VEGA-TABLE-FOOT-CELL')
+          return;
+        const leafCell = cell;
+        const base = this.leavesRenderInputModels[leafIndex];
+        const colSpan = leafCell.colSpan || 1;
+        if (base) {
+          const candidate = ColumnRenderInputModel.withMergedBoundaries(base, this.leavesRenderInputModels.slice(leafIndex, leafIndex + colSpan));
+          if (cell.tagName === 'VEGA-TABLE-FOOT-CELL') {
+            const footCell = leafCell;
+            const current = this.footCellRenderInputMap.get(footCell);
+            const renderInput = this.hasSameCellStructure(current, candidate)
+              ? current
+              : candidate;
+            if (renderInput !== current)
+              this.hasPendingCellRenderInputChange = true;
+            nextFootCellRenderInputMap.set(footCell, renderInput);
+          }
+          else {
+            const bodyCell = leafCell;
+            const current = this.bodyCellRenderInputMap.get(bodyCell);
+            this.addCellRenderInputMap(bodyCell, this.hasSameCellStructure(current, candidate) ? current : candidate);
+          }
+        }
+        leafIndex += colSpan;
+      });
+    });
+    if (nextFootCellRenderInputMap.size !== this.footCellRenderInputMap.size) {
+      this.hasPendingCellRenderInputChange = true;
+    }
+    this.footCellRenderInputMap = nextFootCellRenderInputMap;
+  }
+  /**
+   * 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.
+   */
+  hasSameCellStructure(current, candidate) {
+    return (!!current &&
+      current.key === candidate.key &&
+      current.pinned === candidate.pinned &&
+      current.columnIndex === candidate.columnIndex &&
+      current.isViewStart === candidate.isViewStart &&
+      current.isViewEnd === candidate.isViewEnd &&
+      current.isLeftEndPinned === candidate.isLeftEndPinned &&
+      current.isRightStartPinned === candidate.isRightStartPinned &&
+      current.isNoPinnedEnd === candidate.isNoPinnedEnd);
+  }
+  /** Notify consumers that table render inputs changed. */
+  notifyRenderInputChange() {
+    changeManager.notify(domNodeSubjectFactory.getSubject(this.host, VegaInternalVegaTableRenderInputChange), {});
+  }
+  /**
+   * Create and cache render input for a requesting row.
+   *
+   * @param {HTMLElement} row - Requesting row host.
+   * @returns {RowRenderInputModel} Cached row render input.
+   */
+  createRowRenderInput(row) {
+    const kind = row.matches('vega-table-head-row')
+      ? 'head'
+      : row.matches('vega-table-foot-row')
+        ? 'foot'
+        : row.matches('vega-table-expand-row')
+          ? 'expand'
+          : 'body';
+    const renderInput = this.createRowRenderInputModel(kind, row);
+    this.rowRenderInputMap.set(row, renderInput);
+    return renderInput;
+  }
+  /**
+   * 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.
+   */
+  createRowRenderInputModel(kind, row) {
+    const table = {
+      hasExpandableRow: this.hasExpandableRow,
+      paddingX: this.paddingX,
+      rowDraggable: this.rowDraggable,
+      rowExpandable: this.rowExpandable,
+      rowSelection: this.rowSelection,
+    };
+    return RowRenderInputModel.from(this.columnStructureModel, table, kind, kind === 'head' ? this.headRowRenderInputMap.get(row) : null);
   }
   /**
    * Build the ColumnRenderInputModel forest from the current ColumnStructureModel.
    */
   setRenderInputModel() {
+    this.rowRenderInputMap = new WeakMap();
+    this.footCellRenderInputMap.clear();
     this.columnRenderInputModels = ColumnRenderInputModel.from(this.columnStructureModel);
     this.leavesRenderInputModels = this.columnRenderInputModels.flatMap((model) => model.getLeaves());
   }
@@ -185,6 +458,24 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaTableRenderInputController.prototype, "columnStructureModel", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "hasExpandableRow", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "paddingX", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "rowDraggable", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "rowExpandable", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "rowSelection", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableRenderInputController.prototype, "isTemplateRenderMode", void 0);
 __decorate([
   MapToComponentMethod('connectedCallback')
 ], VegaTableRenderInputController.prototype, "connectedCallback", null);
@@ -200,3 +491,10 @@ __decorate([
 __decorate([
   MapToComponentMethod('watchColumnStructureModel')
 ], VegaTableRenderInputController.prototype, "watchColumnStructureModel", null);
+__decorate([
+  MapToComponentMethod('watchHasExpandableRow'),
+  MapToComponentMethod('watchPaddingX'),
+  MapToComponentMethod('watchRowDraggable'),
+  MapToComponentMethod('watchRowExpandable'),
+  MapToComponentMethod('watchRowSelection')
+], VegaTableRenderInputController.prototype, "watchRowStructure", null);

package/dist/collection/components/vega-table/slimmers/renderers/vega-table-body-renderer.js

@@ -26,7 +26,9 @@ export class VegaTableBodyRenderer extends VegaSlimmer {
           }, editable),
           this.vegaTableExpandRowController.isExpandableRow(record) && (h("vega-table-expand-row", { class: {
               'v-hidden': !isVisibleInCurrentPage,
-            }, key: `vega-table-expanded-row-${rowKey}`, rowKey: rowKey, striped: this.striped && index % 2 === 1 },
+            }, key: `vega-table-expanded-row-${rowKey}`, rowKey: rowKey, striped: this.striped && index % 2 === 1, ref: (ref) => {
+              this.vegaTableRenderInputController.addRowRenderInputMap(ref, 'expand');
+            } },
             h("slot", { name: `${VegaTableExpandRowController.expandRowSlotNamePrefix}${rowKey}` })))));
       })));
     };
@@ -77,3 +79,6 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaTableBodyRenderer.prototype, "vegaTableExpandRowController", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableBodyRenderer.prototype, "vegaTableRenderInputController", void 0);

package/dist/collection/components/vega-table/slimmers/renderers/vega-table-header-renderer.js

@@ -23,6 +23,7 @@ export class VegaTableHeaderRenderer extends VegaSlimmer {
         var _a;
         return (h("vega-table-head-row", { hideSelectAll: (_a = this.rowSelection) === null || _a === void 0 ? void 0 : _a.hideSelectAll, ref: (ref) => {
             this.vegaTableRenderInputController.addHeadRowRenderInputMap(ref, cells);
+            this.vegaTableRenderInputController.addRowRenderInputMap(ref, 'head');
           } }, cells.map((renderInput) => {
           if (renderInput.label) {
             return this.renderGroupCell(renderInput);