@mmlogic/components 0.5.10 → 0.5.12

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

@@ -15,8 +15,14 @@ export declare class MrdTable {
     private keydownHandler;
     private createPickerClickHandler;
     private viewPopoverClickHandler;
+    /** Watches the host for gaining a box (e.g. its tab pane being shown) — see componentDidLoad. */
+    private resizeObserver;
     /** Guards against scheduling more than one column-width measurement per freeze. */
     private colWidthMeasureScheduled;
+    /** True once the header/totals widths have been checked against the current totals row. */
+    private fixedContentMeasured;
+    /** Guards against scheduling more than one grow pass. */
+    private growScheduled;
     /** Drag origin of the running column resize (null = no drag in progress). */
     private resizeOrigin;
     /** True once the user has dragged (or auto-fitted) a column — see colWidthsUserSet usages. */
@@ -160,12 +166,31 @@ export declare class MrdTable {
     setAggregations(data: AggregationResult): Promise<void>;
     disconnectedCallback(): void;
     componentDidRender(): void;
+    /** Freeze the column widths once the first data page has rendered.
+     *
+     *  The measurement reads layout and writes the colWidths @State, which would trigger a
+     *  re-render *during* the render cycle if done synchronously from componentDidRender. It is
+     *  deferred to a writeTask so the state mutation happens outside the render pass (avoids the
+     *  Stencil "state/prop changed during rendering" warning and potential loops).
+     *
+     *  NB: the freeze must not depend on the totalElements prop — hosts may omit it and rely on
+     *  minKnownTotal, in which case the widths would never be locked and every incoming page
+     *  would re-flow all columns. */
+    private freezeColWidths;
     /** Current rendered header widths, or null when they can't be trusted (header not laid out yet). */
     private measureColWidths;
     /** Width one cell needs to show its content in full, borders included.
      *  Read from scrollWidth rather than the laid-out box: cells clip with `overflow: hidden`,
      *  so a squeezed cell reports the width it *was given*, not the width it needs. */
     private neededWidth;
+    /** Width a header cell needs, measured from its children instead of the cell's own
+     *  scrollWidth. A header is not just text: it holds the label plus a sort icon (and a filter
+     *  icon once the column is filtered), with the drag handle absolutely positioned on top of
+     *  the right padding. Summing the in-flow children makes the icons part of the width by
+     *  construction — and a child's own rect is never clipped by the header's `overflow: hidden`,
+     *  so it stays correct even when the header is already truncated on screen.
+     *  Returns 0 when nothing can be measured, so callers fall back to neededWidth(). */
+    private neededHeaderWidth;
     /** Width each column needs for its header and its rendered page-0 cells — what the columns
      *  are locked to, so they never end up narrower than their content.
      *
@@ -175,6 +200,20 @@ export declare class MrdTable {
      *  exceed the container again, and `.mrd-table__scroll` scrolls. Capped per column at
      *  MAX_AUTOFIT_WIDTH so one outlier value can't blow up the layout — same cap as auto-fit. */
     private measureContentWidths;
+    /** Data and totals cells of one column. The totals row is included everywhere the data
+     *  cells are: it is fixed, always-visible content, so it must never be clipped. */
+    private columnCellSelector;
+    /** Width the header and totals cells of each column need. Null when nothing has a box. */
+    private measureFixedContentWidths;
+    /** Widen columns whose header or totals cell does not fit. Data cells may be ellipsised —
+     *  that is what the lock is for — but the header and the totals row are fixed content that
+     *  is always on screen, so clipping them just hides information with no way to reveal it.
+     *
+     *  It runs as a second pass because the totals only arrive with setAggregations(), long
+     *  after the widths were frozen on page 0. Grow-only and once per totals change, so it can
+     *  never turn into the per-page re-proportioning the lock exists to prevent. Hand-set
+     *  widths are left alone. */
+    private growToFixedContent;
     /** Re-reads the rendered header widths into colWidths so a drag starts from what is
      *  actually on screen — and locks the columns if they weren't locked yet.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmlogic/components",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Stencil.js web component library for dynamic forms and virtual-scroll data tables",
   "license": "MIT",
   "author": "Mosterd",