@mono-lit/helper 0.0.5 → 0.0.7

package/dist/{popup-portal-C8ttHDRX.js → popup-portal-CINuVjNY.js}

@@ -233,6 +233,8 @@ var PopupPortalController = class {
 		this._classObserver = null;
 		this._viewportBound = false;
 		this._viewportFrame = 0;
+		this._wasOpen = false;
+		this._sizeObserver = null;
 		this._onViewport = () => {
 			if (!this.opts.isOpen() || this._viewportFrame) return;
 			this._viewportFrame = requestAnimationFrame(() => {
@@ -254,24 +256,65 @@ var PopupPortalController = class {
 	hostDisconnected() {
 		this._unbindViewport();
 		this._leaveStack();
+		this._unobserveSize();
+		this._wasOpen = false;
 		this._classObserver?.disconnect();
 		this._classObserver = null;
 		if (this._portal?.parentNode) this._portal.parentNode.removeChild(this._portal);
 		this._portal = null;
 		this._adopted = false;
 	}
+	/**
+	* Position SYNCHRONOUSLY only on the open edge; every later update of an open popup is
+	* coalesced into one frame (`scheduleReposition`), and the custom-property carry-over
+	* (`_syncPortalVars`, two `getComputedStyle`) runs on the open edge only.
+	*
+	* `reposition()` is a write-then-read forced layout, and hosts update constantly while open —
+	* every keystroke in a search box, every arrow-key cursor move, every controller notify — so
+	* running it per update cost one synchronous layout each. A frame callback still runs before
+	* that frame paints, so nothing visibly lags; a panel whose content resizes WITHOUT a host
+	* update (a consumer re-rendering its rows) is caught by the ResizeObserver instead.
+	*/
 	hostUpdated() {
 		if (isServer) return;
 		if (this.opts.isOpen()) {
+			const opening = !this._wasOpen;
+			this._wasOpen = true;
 			this._adopt();
 			this._enterStack();
-			this._syncPortalClass();
-			this.reposition();
+			if (opening) {
+				this._syncPortalClass();
+				this.reposition();
+				this._observeSize();
+			} else {
+				this._syncPortalClass(false);
+				this.scheduleReposition();
+			}
 		} else {
+			this._wasOpen = false;
+			this._unobserveSize();
 			this._leaveStack();
-			this._syncPortalClass();
+			this._syncPortalClass(false);
 		}
 	}
+	/** Reposition when the panel or its anchor changes size while open (content, chips wrapping). */
+	_observeSize() {
+		if (this._sizeObserver || typeof ResizeObserver === "undefined") return;
+		const panel = this._panel ?? this.opts.getPanel();
+		const anchor = this.opts.getAnchor();
+		if (!panel && !anchor) return;
+		this._sizeObserver = new ResizeObserver(() => this.scheduleReposition());
+		if (panel) this._sizeObserver.observe(panel);
+		if (anchor) this._sizeObserver.observe(anchor);
+	}
+	_unobserveSize() {
+		this._sizeObserver?.disconnect();
+		this._sizeObserver = null;
+	}
+	/** Reposition on the next frame, coalesced with any viewport movement already pending. */
+	scheduleReposition() {
+		this._onViewport();
+	}
 	/**
 	* Only relocate to `<body>` when the host renders into light DOM
 	* (`renderRoot === host`). Shadow hosts keep the panel in their shadow root.
@@ -307,8 +350,12 @@ var PopupPortalController = class {
 		this._panel = panel;
 		this._adopted = true;
 	}
-	/** Mirror the style-scope element's classes and `mono-*` attributes onto the portal. */
-	_syncPortalClass() {
+	/**
+	* Mirror the style-scope element's classes and `mono-*` attributes onto the portal.
+	* `withVars` also carries the custom properties across — a computed-style read, so only on
+	* the open edge and on a scope attribute change, not on every host update.
+	*/
+	_syncPortalClass(withVars = true) {
 		if (!this._portal) return;
 		const scope = this.opts.getStyleScope();
 		const cls = scope?.getAttribute("class") ?? "";
@@ -320,7 +367,7 @@ var PopupPortalController = class {
 		}
 		for (const a of Array.from(this._portal.attributes)) if (mirrored(a.name) && !wanted.has(a.name)) this._portal.removeAttribute(a.name);
 		for (const [name, value] of wanted) if (this._portal.getAttribute(name) !== value) this._portal.setAttribute(name, value);
-		this._syncPortalVars(scope);
+		if (withVars) this._syncPortalVars(scope);
 	}
 	/**
 	* Carry the component's public custom properties across the portal (see

package/dist/src/components/accordion/mono-accordion.d.ts

@@ -15,7 +15,6 @@ declare const MonoAccordion_base: Constructor<MonoAccordionCoreInterface> & type
  * Both register `mono-accordion`, so a document loads only one.
  */
 export declare class MonoAccordion extends MonoAccordion_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotObserver?;
   private _slotTitle;

package/dist/src/components/alert/mono-alert.d.ts

@@ -18,7 +18,6 @@ declare const MonoAlert_base: Constructor<MonoAlertCoreInterface> & typeof LitEl
  * rendered, and their captured nodes are parked (kept parented, invisible).
  */
 export declare class MonoAlert extends MonoAlert_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/breadcrumb/mono-breadcrumb-list.d.ts

@@ -16,7 +16,6 @@ declare const MonoBreadcrumbList_base: Constructor<MonoBreadcrumbListCoreInterfa
  *     (`@mono-lit/helper/ui/shadow/breadcrumb`) supports standalone only.
  */
 export declare class MonoBreadcrumbList extends MonoBreadcrumbList_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _parent;
   connectedCallback(): void;

package/dist/src/components/breadcrumb/mono-breadcrumb.d.ts

@@ -18,7 +18,6 @@ declare const MonoBreadcrumb_base: Constructor<MonoBreadcrumbCoreInterface> & ty
  * so a document loads only one.
  */
 export declare class MonoBreadcrumb extends MonoBreadcrumb_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _hasBodySlot;

package/dist/src/components/button/mono-button-dropdown.d.ts

@@ -17,7 +17,6 @@ declare const MonoButtonDropdown_base: Constructor<MonoButtonDropdownCoreInterfa
  * build shares it and only swaps the embedded button's tag.
  */
 export declare class MonoButtonDropdown extends MonoButtonDropdown_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   /**
    * The panel is a STATIC element here, not something a helper returns.

package/dist/src/components/button/mono-button.d.ts

@@ -22,7 +22,6 @@ declare const MonoButton_base: Constructor<MonoButtonCoreInterface> & typeof Lit
  * document loads only one.
  */
 export declare class MonoButton extends MonoButton_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/card/mono-card.d.ts

@@ -24,7 +24,6 @@ declare const MonoCard_base: Constructor<MonoCardCoreInterface> & typeof LitElem
  * same document.
  */
 export declare class MonoCard extends MonoCard_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/chart/mono-chart-presets.d.ts

@@ -6,7 +6,6 @@ import { LitElement, TemplateResult } from "lit";
 declare const MonoChartBar_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-bar>` — vertical bars. */
 export declare class MonoChartBar extends MonoChartBar_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -14,7 +13,6 @@ export declare class MonoChartBar extends MonoChartBar_base {
 declare const MonoChartLine_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-line>` — a line series. */
 export declare class MonoChartLine extends MonoChartLine_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -22,7 +20,6 @@ export declare class MonoChartLine extends MonoChartLine_base {
 declare const MonoChartPie_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-pie>` — pie slices. */
 export declare class MonoChartPie extends MonoChartPie_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -30,7 +27,6 @@ export declare class MonoChartPie extends MonoChartPie_base {
 declare const MonoChartDoughnut_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-doughnut>` — a pie with a hole. */
 export declare class MonoChartDoughnut extends MonoChartDoughnut_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;

package/dist/src/components/chart/mono-chart.d.ts

@@ -21,7 +21,6 @@ declare const MonoChart_base: Constructor<MonoChartCoreInterface> & typeof LitEl
  * ```
  */
 export declare class MonoChart extends MonoChart_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
 }

package/dist/src/components/checkbox/mono-checkbox.d.ts

@@ -17,7 +17,6 @@ declare const MonoCheckbox_base: Constructor<MonoCheckboxCoreInterface> & typeof
  * document loads only one.
  */
 export declare class MonoCheckbox extends MonoCheckbox_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotIcon;

package/dist/src/components/chip/mono-chip.d.ts

@@ -21,7 +21,6 @@ declare const MonoChip_base: Constructor<MonoChipCoreInterface> & typeof LitElem
  * only one.
  */
 export declare class MonoChip extends MonoChip_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/date/mono-date.d.ts

@@ -14,7 +14,6 @@ declare const MonoDate_base: Constructor<MonoDateCoreInterface> & typeof LitElem
  * `mono-date`, so a document loads one.
  */
 export declare class MonoDate extends MonoDate_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/drawer/mono-drawer.d.ts

@@ -17,7 +17,6 @@ declare const MonoDrawer_base: Constructor<MonoDrawerCoreInterface> & typeof Lit
  * `mono-drawer.shadow.ts`; all logic is shared via `MonoDrawerCore`.
  */
 export declare class MonoDrawer extends MonoDrawer_base {
-  static styles: import("lit").CSSResult[];
   private _portal;
   private _appliedPortalClasses;
   private _slotHeader;

package/dist/src/components/dropdown/mono-dropdown.d.ts

@@ -15,7 +15,6 @@ declare const MonoDropdown_base: Constructor<MonoDropdownCoreInterface> & typeof
  * `<slot>`. Both register `mono-dropdown`, so a document loads only one.
  */
 export declare class MonoDropdown extends MonoDropdown_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _hasBodySlotState;
   private _slotsCaptured;

package/dist/src/components/dropdown-table/mono-dropdown-table.d.ts

@@ -30,7 +30,6 @@ declare const MonoDropdownTable_base: Constructor<MonoDropdownTableCoreInterface
  * </mono-dropdown-table>
  */
 export declare class MonoDropdownTable extends MonoDropdownTable_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotSearch;

package/dist/src/components/file-upload/mono-file-upload.d.ts

@@ -17,7 +17,6 @@ declare const MonoFileUpload_base: Constructor<MonoFileUploadCoreInterface> & ty
  * `mono-file-upload`, so a document loads only one.
  */
 export declare class MonoFileUpload extends MonoFileUpload_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slots;

package/dist/src/components/filter/mono-filter-builder.d.ts

@@ -11,7 +11,6 @@ declare const MonoFilterBuilder_base: Constructor<MonoFilterBuilderCoreInterface
  * the same global `dist/ui/index.css` — so no extra stylesheet is needed here.
  */
 export declare class MonoFilterBuilder extends MonoFilterBuilder_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   protected renderIcon(name: FilterIconName): TemplateResult;
 }

package/dist/src/components/input/mono-input.d.ts

@@ -15,7 +15,6 @@ declare const MonoInput_base: Constructor<MonoInputCoreInterface> & typeof LitEl
  * `<slot>`. Both register `mono-input`, so a document loads only one.
  */
 export declare class MonoInput extends MonoInput_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotPrefix;
   private _slotSuffix;

package/dist/src/components/menu/mono-menu.d.ts

@@ -13,7 +13,6 @@ declare const MonoMenu_base: Constructor<MonoMenuCoreInterface> & typeof LitElem
  * lives in `MonoMenuCore`.
  */
 export declare class MonoMenu extends MonoMenu_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _hasBodySlot;

package/dist/src/components/modal/mono-modal.d.ts

@@ -17,7 +17,6 @@ declare const MonoModal_base: Constructor<MonoModalCoreInterface> & typeof LitEl
  * `mono-modal.shadow.ts`; all logic is shared via `MonoModalCore`.
  */
 export declare class MonoModal extends MonoModal_base {
-  static styles: import("lit").CSSResult[];
   private _portal;
   private _appliedPortalClasses;
   private _slotHead;

package/dist/src/components/nav/mono-nav.d.ts

@@ -17,7 +17,6 @@ declare const MonoNav_base: Constructor<MonoNavCoreInterface> & typeof LitElemen
  * given document must load only one of the two builds.
  */
 export declare class MonoNav extends MonoNav_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotNodes;

package/dist/src/components/otp/mono-otp.d.ts

@@ -12,7 +12,6 @@ declare const MonoOtp_base: Constructor<MonoOtpCoreInterface> & typeof LitElemen
  * build (`mono-shadow-otp`) shares it with native `<slot>`s.
  */
 export declare class MonoOtp extends MonoOtp_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slots;
   private _slotObserver?;

package/dist/src/components/radio/mono-radio.d.ts

@@ -16,7 +16,6 @@ declare const MonoRadio_base: Constructor<MonoRadioCoreInterface> & typeof LitEl
  * document loads only one.
  */
 export declare class MonoRadio extends MonoRadio_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/rich-text-editor/mono-rich-text-editor.d.ts

@@ -16,7 +16,6 @@ declare const MonoRichTextEditor_base: Constructor<MonoRichTextEditorCoreInterfa
  * `MonoRichTextEditorCore`.
  */
 export declare class MonoRichTextEditor extends MonoRichTextEditor_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/select/mono-select.d.ts

@@ -15,7 +15,6 @@ declare const MonoSelect_base: Constructor<MonoSelectCoreInterface> & typeof Lit
  * register `mono-select`, so a document loads only one build.
  */
 export declare class MonoSelect extends MonoSelect_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/sidebar/mono-sidebar.d.ts

@@ -16,7 +16,6 @@ declare const MonoSidebar_base: Constructor<MonoSidebarCoreInterface> & typeof L
  * Both register `mono-sidebar`, so a document loads only one.
  */
 export declare class MonoSidebar extends MonoSidebar_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotHeader;

package/dist/src/components/slider/mono-slider.d.ts

@@ -12,7 +12,6 @@ declare const MonoSlider_base: Constructor<MonoSliderCoreInterface> & typeof Lit
  * `MonoSliderCore`; the shadow build (`mono-shadow-slider`) shares it with native `<slot>`s.
  */
 export declare class MonoSlider extends MonoSlider_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotLabel;
   private _slotHelper;

package/dist/src/components/switch/mono-switch.d.ts

@@ -16,7 +16,6 @@ declare const MonoSwitch_base: Constructor<MonoSwitchCoreInterface> & typeof Lit
  * Both register `mono-switch`, so a document loads only one.
  */
 export declare class MonoSwitch extends MonoSwitch_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotLabel;

package/dist/src/components/table/column-autosize.d.ts

@@ -0,0 +1,96 @@
+import { CssSizeValue } from "../../composables/css-size.js";
+//#region src/components/table/column-autosize.d.ts
+/**
+ * Content-sized columns — what `mono-table-th`'s `width="auto"` drives.
+ *
+ * Under `mono-table-fixed` (`table-layout: fixed`) CSS cannot do this: an `auto` column takes
+ * the WHOLE surplus instead of fitting its content, and `min-width` / `max-width` on a cell are
+ * ignored by the table algorithm. So the column is measured here and handed a concrete px width,
+ * clamped to `minWidth` / `maxWidth`, written to its `<col>` (which wins under fixed layout) and
+ * to the header cell.
+ *
+ * Text is measured with a canvas, not read back from the cell: reading the cell's own width would
+ * return the width last written, and a column could then never shrink. Measuring text also keeps
+ * the pass free of layout reads, so re-running it on every change is cheap.
+ *
+ * What is measured: the header (caption + its icons), every body cell and every FOOTER cell of
+ * the column. The footer matters — a `<mono-table-summary>` total covers the whole set, so a
+ * virtual-scroll window that only shows small figures still sizes for the largest one.
+ *
+ * Cell content is treated as one line (what a money column is). An editor (`<input>`, including
+ * the one inside `mono-input`) counts with its value and its own padding / border.
+ */
+/** The text measurer — swappable so tests can run where there is no canvas (jsdom). */
+export declare const autosizeEnv: {
+  measure: (text: string, font: string) => number;
+};
+/**
+ * `text` as the element renders it: its `text-transform`, its `letter-spacing` (canvas ignores
+ * both) and its `font-variant-numeric: tabular-nums` (every digit at the widest digit's advance —
+ * a safe upper bound; tabular figures are wider than the proportional ones canvas measures).
+ */
+export declare function measureStyled(text: string, style: CSSStyleDeclaration): number;
+/**
+ * A size prop as px: a number / bare numeric string / `px` → px, `rem` → × the root font size,
+ * `em` → × `el`'s font size. Anything else (`%`, `auto`, a var) → `undefined`: not a bound.
+ */
+export declare function cssLengthToPx(value: CssSizeValue | null, el?: Element): number | undefined;
+/** `w` clamped to `[min, max]`; an unset bound does not clamp. `min` wins over a smaller `max`. */
+export declare function clampWidth(w: number, min?: number, max?: number): number;
+/**
+ * The grid column a header cell STARTS at — a walk over its section's rows honouring `rowspan`
+ * and `colspan`, so a leaf header under a band row (`<th colspan>` above it) maps to its real
+ * column. `cellIndex` alone would count only the cells of its own row.
+ */
+export declare function headerColumnIndex(cell: HTMLTableCellElement): number;
+/** The one-line width a cell's content needs, padding included. */
+export declare function contentWidth(cell: HTMLElement): number;
+/**
+ * One auto-sized column, owned by its `mono-table-th`. `schedule()` coalesces every trigger (a
+ * controller notify, a body mutation, typing in an editor) into one measurement per frame.
+ */
+export declare class ColumnAutoSize {
+  private readonly host;
+  min?: number;
+  max?: number;
+  /**
+   * Never shrink — for a virtual-scroll table, whose body holds only the WINDOW of the rows: each
+   * window shift measured a different slice, so the column grew and shrank as the list scrolled and
+   * every change relaid the whole table. The column settles at the widest value seen instead, until
+   * `resetFloor()` (a new result set).
+   */
+  growOnly: boolean;
+  private _floor;
+  private _raf;
+  private _table?;
+  private _observer?;
+  private _wrote?;
+  private readonly _onInput;
+  /**
+   * A web font that finished loading after a measurement: canvas measured the FALLBACK face, so
+   * the width (and the cached digit advances) are stale — usually too narrow for the real font.
+   */
+  private readonly _onFonts;
+  constructor(host: HTMLElement);
+  /**
+   * Every sizer on the page shares ONE frame callback (`_flush`), which measures all of them
+   * first and writes all of them after.
+   *
+   * Each used to run in its own frame callback, measure-then-write: column A wrote its width,
+   * so column B's measurement (`getBoundingClientRect` on header icons, an SVG) forced a
+   * synchronous layout of the whole table — one per auto column, per frame.
+   */
+  private static _queued;
+  private static _frame;
+  private static _flush;
+  schedule(): void;
+  /** Forget the grow-only floor (new rows) and re-measure. */
+  resetFloor(): void;
+  /** Stop watching, and hand the column back to whatever width it is given next. */
+  stop(clear?: boolean): void;
+  private _watch;
+  private _unwatch;
+  /** Measure now (reads only); returns the write to apply after every sizer has measured. */
+  private _measure;
+}
+//#endregion

package/dist/src/components/table/mono-data-grid.d.ts

@@ -298,7 +298,17 @@ export interface MonoTableColumnProps {
    * @example map: (v) => formatDateTime(v)
    */
   map?: (value: any, row: any, index: number) => unknown;
+  /**
+   * Column width. Number → px; string used as-is (`'10rem'`). `'auto'` sizes the column to its
+   * content (header, body and footer cells), clamped to `minWidth` / `maxWidth` — also under
+   * `mono-table-fixed`. Money columns are the case: narrow while every figure is `0`, wider
+   * once a large one appears.
+   */
   width?: string | number;
+  /** Lower bound of the column width (px / `rem` / `em`). Clamps `width: 'auto'`. */
+  minWidth?: string | number;
+  /** Upper bound of the column width (px / `rem` / `em`). Clamps `width: 'auto'`. */
+  maxWidth?: string | number;
   height?: string | number;
   /**
    * Header alignment: `'left' | 'center' | 'right'`. Applied to the column's `<th>`.
@@ -474,6 +484,12 @@ export interface MonoCheckHandle<T = any> {
   selectAll(): Promise<void>;
   /** Empty the selection. */
   clear(): void;
+  /**
+   * Increments on every selection notify — tick, untick (even a rejected one), page / all
+   * select, replace, clear, and the drain's start / end. Compare it to tell "the selection
+   * moved" from the grid's other notifies (a load, a virtual-scroll window shift).
+   */
+  readonly version: number;
   /** Whether a `selectAll()` drain is in flight. */
   readonly pending: boolean;
   /** Every loaded row is selected (and there is at least one). */

package/dist/src/components/table/mono-table-checkbox.d.ts

@@ -26,7 +26,6 @@ declare const MonoTableCheckbox_base: Constructor<MonoTableCheckboxCoreInterface
  * table.check().getAll()   // [{ Id: 8 }, { Id: 12 }, … ]
  */
 export declare class MonoTableCheckbox extends MonoTableCheckbox_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-detail.d.ts

@@ -24,7 +24,6 @@ declare const MonoTableDetail_base: Constructor<MonoTableDetailCoreInterface> &
  * </tr>
  */
 export declare class MonoTableDetail extends MonoTableDetail_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-empty.d.ts

@@ -22,7 +22,6 @@ declare const MonoTableEmpty_base: Constructor<MonoTableEmptyCoreInterface> & ty
  * INTO the host and would otherwise overwrite it.
  */
 export declare class MonoTableEmpty extends MonoTableEmpty_base {
-  static styles: import("lit").CSSResult[];
   private _buckets;
   private _slotsCaptured;
   protected createRenderRoot(): HTMLElement;

package/dist/src/components/table/mono-table-error.d.ts

@@ -20,7 +20,6 @@ declare const MonoTableError_base: Constructor<MonoTableErrorCoreInterface> & ty
  * which is exactly what a light build can use and a shadow one cannot.
  */
 export declare class MonoTableError extends MonoTableError_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-info.d.ts

@@ -11,7 +11,6 @@ declare const MonoTableInfo_base: Constructor<MonoTableInfoCoreInterface> & type
  * so a document loads only one.
  */
 export declare class MonoTableInfo extends MonoTableInfo_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-loading.d.ts

@@ -42,7 +42,6 @@ declare const MonoTableLoading_base: Constructor<MonoTableLoadingCoreInterface>
  * </div>
  */
 export declare class MonoTableLoading extends MonoTableLoading_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-page-size.d.ts

@@ -8,7 +8,6 @@ declare const MonoTablePageSize_base: Constructor<MonoTablePageSizeCoreInterface
  * All logic lives in `MonoTablePageSizeCore`; the shadow build shares the mixin.
  */
 export declare class MonoTablePageSize extends MonoTablePageSize_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-paging-group.d.ts

@@ -12,7 +12,6 @@ declare const MonoTablePagingGroup_base: Constructor<MonoTablePagingGroupCoreInt
  * <mono-table-paging-group :data-grid.prop="table" :group.prop="node" page-size="5" />
  */
 export declare class MonoTablePagingGroup extends MonoTablePagingGroup_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-paging.d.ts

@@ -8,7 +8,6 @@ declare const MonoTablePaging_base: Constructor<MonoTablePagingCoreInterface> &
  * All logic lives in `MonoTablePagingCore`; the shadow build shares the mixin.
  */
 export declare class MonoTablePaging extends MonoTablePaging_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-search.d.ts

@@ -12,7 +12,6 @@ declare const MonoTableSearch_base: Constructor<MonoTableSearchCoreInterface> &
  * `dist/ui/index.css` — so no extra stylesheet is needed for the light build.
  */
 export declare class MonoTableSearch extends MonoTableSearch_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   /**
    * Light-DOM slot capture (mirrors `mono-dropdown-table`): a real `<slot>` can't

package/dist/src/components/table/mono-table-sort.d.ts

@@ -20,7 +20,6 @@ declare const MonoTableSort_base: Constructor<MonoTableSortCoreInterface> & type
  * <th><mono-table-sort :data-grid.prop="table" field="Nama">Name</mono-table-sort></th>
  */
 export declare class MonoTableSort extends MonoTableSort_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   /** The captured label nodes (the element's original light-DOM children). */
   private _buckets;

package/dist/src/components/table/mono-table-summary.d.ts

@@ -16,7 +16,6 @@ declare const MonoTableSummary_base: Constructor<MonoTableSummaryCoreInterface>
  * build shares the mixin. Both register the same tag, so a document loads one.
  */
 export declare class MonoTableSummary extends MonoTableSummary_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {

package/dist/src/components/table/mono-table-th-core.d.ts

@@ -1,4 +1,5 @@
 import { Constructor } from "../../composables/hybird-prop.js";
+import { CssSizeValue } from "../../composables/css-size.js";
 import { MonoColumnSort, MonoDateFilter, MonoEditableTrigger, MonoHeaderFilter, SortOrder } from "./mono-data-grid.js";
 import { MonoTableMenuCoreInterface } from "./table-menu-core.js";
 import { LitElement, TemplateResult } from "lit";
@@ -26,6 +27,8 @@ export declare class MonoTableThCoreInterface extends MonoTableMenuCoreInterface
   dateFilter: boolean | MonoDateFilter;
   align?: TableThAlign;
   width?: string | number;
+  minWidth?: CssSizeValue;
+  maxWidth?: CssSizeValue;
   height?: string | number;
   protected renderSlot(name: TableThSlotName): TemplateResult;
   protected renderIcon(name: TableThIconName): TemplateResult;