@mono-lit/helper 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,41 @@
+import { LitElement } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public surface added by the loading-overlay core mixin. */
+export declare class MonoTableLoadingCoreInterface extends MonoTableControllerCoreInterface {
+    minDuration: number;
+    loading: boolean | null;
+}
+/**
+ * `MonoTableLoadingCore` — render-mode-agnostic logic for `mono-table-loading`, a
+ * drop-in spinner overlay shown over the table whenever the bound controller is
+ * fetching (sort / search / paging / reload / save). Place it in the
+ * `.mono-table-scroll` wrapper, or inside the `<table>` wrapped in a `<caption>`
+ * (a bare custom-element child of `<table>` is invalid HTML — see the tag doc),
+ * and bind the controller with `:data-grid.prop` — no `v-show` wiring.
+ *
+ * It reads `dataGrid.loading` **synchronously on every controller notify** (not in
+ * an async render) so it can't miss a fast query whose `loading` flips back before
+ * Lit re-renders, and holds the overlay for a small minimum duration
+ * (`min-duration`, default 350ms) so the feedback is always perceptible. The
+ * overlay itself is toggled by an imperative `data-loading` attribute + CSS — the
+ * element never needs to re-render for the state to flip.
+ *
+ * "Just works" details, applied to the nearest overlay host — the enclosing
+ * `.mono-table-scroll` if present, else the `<table>`:
+ *  - makes it a positioning context (`position: relative`) so the absolute overlay
+ *    covers it (the consumer adds nothing);
+ *  - holds the grid's height while active, so a source that momentarily clears its rows
+ *    mid-query can't collapse it to a thin strip. The hold goes on the nearest BLOCK box (the
+ *    scroll wrapper, else the table's parent) — never on the `<table>`, which would distribute
+ *    the height over its rows and stretch the header instead of reserving space.
+ *
+ * MANUAL mode: set `loading` (`:loading="isBusy"`) and the element follows THAT instead of the
+ * controller — for a busy state the controller can't see (several requests, a save in a store,
+ * a page with no controller at all). `true` shows, `false` hides, whatever the controller says;
+ * `null` / `undefined` (or no attribute) hands it back to the controller. `min-duration` holds
+ * for both sources.
+ *
+ * SSR-safe: all DOM/timer work is guarded behind `isServer`.
+ */
+export declare const MonoTableLoadingCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableLoadingCoreInterface> & T;

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

@@ -0,0 +1,50 @@
+import { LitElement } from 'lit';
+declare const MonoTableLoading_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-loading-core.js').MonoTableLoadingCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-loading` (default build, `@mono-lit/helper/ui/table`). A
+ * drop-in loading overlay — place it inside your `<table>` (or `.mono-table-scroll`)
+ * and bind the controller with `:data-grid.prop`; it auto-shows a spinner over
+ * the rows region whenever the controller is fetching and freezes the grid height
+ * so it can't collapse mid-query. Renders into the host
+ * (`createRenderRoot`→`this`, styled by the global `dist/ui/index.css`); all logic
+ * lives in `MonoTableLoadingCore`, shared with the shadow build.
+ *
+ * Place it in the `.mono-table-scroll` wrapper, or INSIDE the `<table>` wrapped in
+ * a row section — drop it straight into `<tbody>`.
+ *
+ * `<table>`'s content model permits only `caption`/`colgroup`/`thead`/`tbody`/`tfoot`,
+ * and a row section permits only `<tr>`, so a bare custom-element child of either is
+ * invalid: Vue's compiler warns, and the HTML parser foster-parents it out of the
+ * table on hydration. The element handles that itself — on connect it wraps itself in
+ * a zero-height `<tr class="mono-table-loading-row" mono-loading-row><td colspan>`, so the markup you
+ * write stays one line and the overlay stays inside the table.
+ *
+ * It covers the `<table>`, NOT the scroll wrapper, and that is what makes it survive
+ * scrolling: an absolutely positioned descendant of a scroll container scrolls WITH
+ * the content, so covering the wrapper would pin the dim to the scroll origin at the
+ * scrollport's size and let rows show through beside it. The spinner is
+ * `position: sticky`, so it stays in view on a table far wider or longer than its
+ * region.
+ *
+ * A `<caption>` or a `<td>` you wrote yourself is left alone — both are valid hosts,
+ * so existing markup keeps working unchanged.
+ *
+ * @example
+ * <div class="mono-table-scroll" mono-table-scroll>
+ *   <table class="mono-table" mono-table>
+ *     <caption><mono-table-loading :data-grid.prop="table" /></caption>
+ *     <thead>…</thead>
+ *     <tbody>…rows…</tbody>
+ *   </table>
+ * </div>
+ */
+export declare class MonoTableLoading extends MonoTableLoading_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-loading': MonoTableLoading;
+    }
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+declare const MonoTableLoadingShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-loading-core.js').MonoTableLoadingCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-loading` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ * Renders the spinner into a real shadow root; the `host: 'mono-table-loading'`
+ * rewrite turns the overlay's element-selector rules into `:host` so the shadow
+ * sheet self-contains the overlay styling. The `loading` state is client-only, so
+ * SSR emits an inert (hidden) host. Shares all logic via `MonoTableLoadingCore`.
+ */
+export declare class MonoTableLoadingShadow extends MonoTableLoadingShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public surface added by the page-size core mixin. */
+export declare class MonoTablePageSizeCoreInterface extends MonoTableControllerCoreInterface {
+    sizes: Array<number | 'all'> | string;
+    label: string;
+}
+/**
+ * `MonoTablePageSizeCore` — render-mode-agnostic logic for `mono-table-page-size`:
+ * a native `<select>` of page-size options wired to the controller. No slots, no
+ * icons — light and shadow share the full `render()`.
+ */
+export declare const MonoTablePageSizeCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTablePageSizeCoreInterface> & T;

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

@@ -0,0 +1,16 @@
+import { LitElement } from 'lit';
+declare const MonoTablePageSize_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-page-size-core.js').MonoTablePageSizeCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-page-size` (default build, `@mono-lit/helper/ui/table`).
+ * 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 {
+    interface HTMLElementTagNameMap {
+        'mono-table-page-size': MonoTablePageSize;
+    }
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { LitElement } from 'lit';
+declare const MonoTablePageSizeShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-page-size-core.js').MonoTablePageSizeCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-table-page-size` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ * Shares all logic with the light build via `MonoTablePageSizeCore`.
+ */
+export declare class MonoTablePageSizeShadow extends MonoTablePageSizeShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+export type TablePagingType = 'standard' | 'infinity-scroll' | 'virtual-scroll';
+/** Public surface added by the paging core mixin. */
+export declare class MonoTablePagingCoreInterface extends MonoTableControllerCoreInterface {
+    type: TablePagingType;
+    siblings: number;
+    simple: boolean;
+    size?: number;
+    rowHeight: number;
+    scrollTarget?: string;
+    threshold: number;
+    overscan: number;
+    prevIcon: string;
+    nextIcon: string;
+    protected _renderIcon(direction: 'prev' | 'next'): TemplateResult;
+}
+/** Defaults the shadow build tests against before swapping in its inline SVG. */
+export declare const DEFAULT_PREV_ICON = "i-mdi-chevron-left";
+export declare const DEFAULT_NEXT_ICON = "i-mdi-chevron-right";
+export declare const MonoTablePagingCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTablePagingCoreInterface> & T;

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

@@ -0,0 +1,18 @@
+import { LitElement } from 'lit';
+import { MonoGroupNode } from './grouping.js';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public surface added by the group-paging core mixin. */
+export declare class MonoTablePagingGroupCoreInterface extends MonoTableControllerCoreInterface {
+    group?: MonoGroupNode | string;
+    pageSize: number;
+    siblings: number;
+    simple: boolean;
+}
+/**
+ * `MonoTablePagingGroupCore` — render-mode-agnostic logic for
+ * `mono-table-paging-group`: paginates the rows inside ONE group. Extends the
+ * controller base with group-paging registration on connect / disconnect /
+ * group-path change. No slots, no icons — light and shadow share `render()`.
+ */
+export declare const MonoTablePagingGroupCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTablePagingGroupCoreInterface> & T;

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

@@ -0,0 +1,20 @@
+import { LitElement } from 'lit';
+declare const MonoTablePagingGroup_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-paging-group-core.js').MonoTablePagingGroupCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-paging-group` (default build, `@mono-lit/helper/ui/table`).
+ * Paginates the rows inside a single group. All logic lives in
+ * `MonoTablePagingGroupCore`; the shadow build shares the mixin.
+ *
+ * @example
+ * <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 {
+    interface HTMLElementTagNameMap {
+        'mono-table-paging-group': MonoTablePagingGroup;
+    }
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+declare const MonoTablePagingGroupShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-paging-group-core.js').MonoTablePagingGroupCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-table-paging-group` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ * Shares all logic with the light build via `MonoTablePagingGroupCore`. Renders
+ * `nothing` server-side (no controller), so its host SSRs empty and only
+ * materializes after hydration binds the controller + group.
+ */
+export declare class MonoTablePagingGroupShadow extends MonoTablePagingGroupShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { LitElement } from 'lit';
+declare const MonoTablePaging_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-paging-core.js').MonoTablePagingCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-paging` (default build, `@mono-lit/helper/ui/table`).
+ * 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 {
+    interface HTMLElementTagNameMap {
+        'mono-table-paging': MonoTablePaging;
+    }
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { LitElement } from 'lit';
+declare const MonoTablePagingShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-paging-core.js').MonoTablePagingCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-table-paging` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ * Shares all logic with the light build via `MonoTablePagingCore`.
+ */
+export declare class MonoTablePagingShadow extends MonoTablePagingShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,74 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { MonoSearchValue } from '../../search/data-search.js';
+import { InputCssClass, InputColor, InputSize, InputValidationState, InputVariant } from '../input/input-types.js';
+import { CssSizeValue } from '../../composables/css-size';
+import { Constructor } from '../../composables/hybird-prop';
+/** Per-build icon hooks the search core delegates to. */
+export type TableSearchIconName = 'search' | 'close' | 'chevron';
+/** Public surface added by the search core mixin. */
+export declare class MonoTableSearchCoreInterface extends MonoTableControllerCoreInterface {
+    /** Fields a term matches — replaces `monoDataGrid({ searchExpr })`. */
+    searchValue: MonoSearchValue;
+    /** Alias of {@link searchValue}, under the grid option's older name. */
+    searchExpr: MonoSearchValue;
+    placeholder: string;
+    disabled: boolean;
+    debounce: number;
+    noIcon: boolean;
+    size: InputSize;
+    color: InputColor;
+    variant: InputVariant;
+    readonly: boolean;
+    clearable: boolean;
+    autofocus: boolean;
+    label: string;
+    helperText: string;
+    validationState: InputValidationState;
+    validationMessage: string;
+    error: boolean;
+    errorMessage: string;
+    success: boolean;
+    successMessage: string;
+    name: string;
+    autocomplete: string;
+    inputmode: string;
+    minLength?: number;
+    maxLength?: number;
+    ariaLabelText?: string;
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    cssClass: InputCssClass;
+    cssClassName: string;
+    focus(options?: FocusOptions): void;
+    blur(): void;
+    protected renderIcon(name: TableSearchIconName): TemplateResult;
+    protected _renderFilterSlotContent(): TemplateResult;
+    protected _onFilterSlotChange(e: Event): void;
+    protected _setFilterSlotted(value: boolean): void;
+    protected _filterPanelRoot(): ParentNode | null;
+}
+/**
+ * `MonoTableSearchCore` — render-mode-agnostic logic for `mono-table-search`: a
+ * debounced search box wired to the controller.
+ *
+ * It renders **`mono-input`'s markup and class names** (`.mono-input` →
+ * `.mono-input-field` → `.mono-input-native`) rather than a bespoke box, so the
+ * whole size × color × variant matrix in `input.css` applies verbatim and a
+ * search sitting beside a `<mono-input>` in a toolbar matches it exactly. That is
+ * also why the prop names, attribute names and converters below mirror
+ * `input-core.ts` — markup is portable between the two elements.
+ *
+ * Deliberately NOT taken from `InputProps`: `type` (pinned to `search`),
+ * `required` / `pattern` / `min` / `max` / `step` (form-submit constraints with no
+ * meaning for a filter), and `value` / `modelValue` — the debounce below plus the
+ * controller own the search term.
+ *
+ * The magnifier and clear glyphs are delegated to `renderIcon()` (light: UnoCSS
+ * `.mono-icon i-mdi-*`; shadow: inline SVG) so the chrome is otherwise identical.
+ */
+export declare const MonoTableSearchCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableSearchCoreInterface> & T;

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

@@ -0,0 +1,34 @@
+import { LitElement, TemplateResult } from 'lit';
+import { TableSearchIconName } from './mono-table-search-core.js';
+declare const MonoTableSearch_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-search-core.js').MonoTableSearchCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-search` (default build, `@mono-lit/helper/ui/table`).
+ * The icons use the global UnoCSS `.mono-icon i-mdi-*`. All other logic lives in
+ * `MonoTableSearchCore`; the shadow build shares the mixin.
+ *
+ * The element renders `mono-input`'s classes, whose rules ship in the same global
+ * `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
+     * project when the render root IS the host, so the `slot="filter-builder"`
+     * child is captured here, lifted out of the host, and re-appended into the
+     * `[data-mono-slot]` placeholder the core renders. The node is MOVED (not
+     * cloned), so a Vue-authored `<mono-filter-builder>` keeps its reactivity.
+     */
+    private _slotsCaptured;
+    private _filterSlots;
+    connectedCallback(): void;
+    private _captureFilterSlot;
+    protected updated(changed: Map<string, unknown>): void;
+    protected renderIcon(name: TableSearchIconName): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-search': MonoTableSearch;
+    }
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { LitElement, TemplateResult } from 'lit';
+import { TableSearchIconName } from './mono-table-search-core.js';
+declare const MonoTableSearchShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-search-core.js').MonoTableSearchCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-table-search` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ * The icons are inline SVG — the global `.mono-icon`/`i-mdi-*` utility CSS can't
+ * reach a shadow root. Shares all other logic via `MonoTableSearchCore`.
+ *
+ * The element renders `mono-input`'s classes, and a shadow root can't see the
+ * page stylesheet, so `input.css` is adopted alongside `table.css` — input first
+ * so table rules can still override. `input.css`'s bare `mono-input { }` selector
+ * simply never matches in here, which is harmless.
+ */
+export declare class MonoTableSearchShadow extends MonoTableSearchShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected renderIcon(name: TableSearchIconName): TemplateResult;
+    /** Shadow build projects the slotted filter-builder through a native `<slot>`. */
+    protected _renderFilterSlotContent(): TemplateResult;
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,35 @@
+import { LitElement, TemplateResult } from 'lit';
+import { SortOrder } from './mono-data-grid.js';
+import { MonoTableMenuCoreInterface } from './table-menu-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Slot regions the sort control lays out. */
+export type TableSortSlotName = 'label';
+/** Per-build icon hook the sort core delegates to. */
+export type TableSortIconName = 'chevron';
+/** Public surface added by the sort core mixin. */
+export declare class MonoTableSortCoreInterface extends MonoTableMenuCoreInterface {
+    field: string;
+    caption: string;
+    disabled: boolean;
+    enable: boolean;
+    noClear: boolean;
+    showIcon: boolean;
+    protected renderSlot(name: TableSortSlotName): TemplateResult;
+    protected renderIcon(name: TableSortIconName): TemplateResult;
+    /** Active sort direction, or null. Read by the builds' `renderIcon`. */
+    protected get _current(): SortOrder;
+}
+/**
+ * `MonoTableSortCore` — render-mode-agnostic logic for `mono-table-sort`: a
+ * column-header sort control whose arrow cycles a SINGLE key `asc → desc → none`
+ * (or `asc ↔ desc` with `no-clear`), while right-clicking the header cell opens
+ * the `Sort ›` menu — the only place a multi-key sort can be built. The header
+ * label is delegated to a `renderSlot('label')`
+ * hook (light: a `[data-mono-slot]` placeholder filled with captured nodes;
+ * shadow: native `<slot>`) and the up/down chevrons to `renderIcon('chevron')`
+ * (light: `i-mdi-chevron-*`; shadow: inline SVG).
+ *
+ * `updated()` reflects the sort state onto the parent `<th>`/`<td>` via
+ * `closest()` — guarded by `isServer` (lit) so it never runs during SSR.
+ */
+export declare const MonoTableSortCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableSortCoreInterface> & T;

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

@@ -0,0 +1,38 @@
+import { LitElement, TemplateResult } from 'lit';
+import { TableSortSlotName, TableSortIconName } from './mono-table-sort-core.js';
+declare const MonoTableSort_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-sort-core.js').MonoTableSortCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-sort` (default build, `@mono-lit/helper/ui/table`). A sort
+ * control for a column header — place it inside a native `<th>`.
+ *
+ * Light-DOM Lit replaces the host's children on render, so the user's label
+ * nodes are captured once in `connectedCallback` and re-appended into the
+ * `[data-mono-slot="label"]` placeholder after each render (reusing the same
+ * nodes instead of re-rendering the text, which would otherwise duplicate it).
+ * The sort indicator is a single global UnoCSS icon that swaps with the direction
+ * (neutral `i-fluent-arrow-sort-16-filled` → `i-ri-arrow-up-long-fill` /
+ * `i-ri-arrow-down-long-fill`). All other logic lives in `MonoTableSortCore`; the
+ * shadow build shares the mixin.
+ *
+ * @example
+ * <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;
+    private _slotsCaptured;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    protected renderSlot(_name: TableSortSlotName): TemplateResult;
+    protected renderIcon(_name: TableSortIconName): TemplateResult;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-sort': MonoTableSort;
+    }
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { LitElement, TemplateResult } from 'lit';
+import { TableSortSlotName, TableSortIconName } from './mono-table-sort-core.js';
+declare const MonoTableSortShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-sort-core.js').MonoTableSortCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-table-sort` (SSR build, `@mono-lit/helper/ui/shadow/table`). The
+ * header label projects through a native `<slot>`; the sort indicator is a single
+ * inline SVG that swaps with the direction (the global `i-*` utility CSS can't
+ * reach a shadow root) — the fluent neutral glyph and the ri up/down arrows,
+ * matching the light build. Shares all other logic via `MonoTableSortCore`.
+ *
+ * DSD inside a `<th>` parses fine — the custom element wraps the label, and the
+ * projected slot content is inline flow content.
+ */
+export declare class MonoTableSortShadow extends MonoTableSortShadow_base {
+    static styles: import('lit').CSSResult[];
+    protected renderSlot(_name: TableSortSlotName): TemplateResult;
+    protected renderIcon(_name: TableSortIconName): TemplateResult;
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { LitElement } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { MonoSummaryType } from './mono-data-grid.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public surface added by the summary core mixin. */
+export declare class MonoTableSummaryCoreInterface extends MonoTableControllerCoreInterface {
+    field?: string;
+    type?: MonoSummaryType;
+    name?: string;
+}
+/**
+ * `MonoTableSummaryCore` — render-mode-agnostic logic for `mono-table-summary`: an
+ * aggregate footer cell. The aggregate (type + formatting) is configured centrally
+ * in `monoDataGrid(data, { summary: [...] })`; this element only names which
+ * summary to show (`field`, optionally `type`/`name`) and renders the controller's
+ * formatted result, re-rendering whenever the controller notifies.
+ *
+ * A `field` with no central spec falls back to a `sum` (the controller
+ * auto-registers a default), so a bare `<mono-table-summary field="Price">` also
+ * works with zero config.
+ *
+ * No slots, no icons — light and shadow share the full `render()`.
+ *
+ * SSR-safe: `dataGrid` is undefined on the server, so it renders an empty shell.
+ */
+export declare const MonoTableSummaryCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableSummaryCoreInterface> & T;

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

@@ -0,0 +1,24 @@
+import { LitElement } from 'lit';
+declare const MonoTableSummary_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-summary-core.js').MonoTableSummaryCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-summary` (default build, `@mono-lit/helper/ui/table`). An
+ * aggregate footer cell — drop it into a `<tfoot>` cell in the column you want
+ * summarized and bind the controller with `:data-grid.prop`. The aggregate is
+ * configured centrally in `monoDataGrid(data, { summary: [...] })`; this element
+ * only names which one to show. Add `mono-table-sticky-foot` to the `<table>` to
+ * keep the footer pinned while the body scrolls.
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`). All logic lives in `MonoTableSummaryCore`; the shadow
+ * 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 {
+    interface HTMLElementTagNameMap {
+        'mono-table-summary': MonoTableSummary;
+    }
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+declare const MonoTableSummaryShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-summary-core.js').MonoTableSummaryCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-summary` (the opt-in SSR build,
+ * `@mono-lit/helper/ui/shadow/table`). Renders into a real shadow root so
+ * `@lit-labs/ssr` can serialize it to Declarative Shadow DOM. Shares all logic
+ * with the light build via `MonoTableSummaryCore`. Registers the `mono-shadow-*`
+ * tag — DISTINCT from the light `<mono-table-summary>` — so both can coexist.
+ */
+export declare class MonoTableSummaryShadow extends MonoTableSummaryShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoColumnSort, MonoDateFilter, MonoEditableTrigger, MonoHeaderFilter, SortOrder } from './mono-data-grid.js';
+import { MonoTableMenuCoreInterface } from './table-menu-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Slot regions the header cell lays out. */
+export type TableThSlotName = 'label';
+/** Per-build icon hook the header core delegates to. */
+export type TableThIconName = 'chevron' | 'funnel';
+/**
+ * Horizontal alignment for a column's HEADER cell.
+ *
+ * Numeric columns are the reason this exists: their bodies are right-aligned by the consumer
+ * while the caption stayed left, so every money column read as misaligned.
+ */
+export type TableThAlign = 'left' | 'center' | 'right';
+/** Public surface added by the header-cell core mixin. */
+export declare class MonoTableThCoreInterface extends MonoTableMenuCoreInterface {
+    field: string;
+    caption: string;
+    sort?: boolean | MonoColumnSort;
+    editable: boolean;
+    editableTrigger?: MonoEditableTrigger;
+    required: boolean;
+    headerFilter: boolean | MonoHeaderFilter;
+    dateFilter: boolean | MonoDateFilter;
+    align?: TableThAlign;
+    width?: string | number;
+    height?: string | number;
+    protected renderSlot(name: TableThSlotName): TemplateResult;
+    protected renderIcon(name: TableThIconName): TemplateResult;
+    /** Active sort direction for this column, or null. Read by the builds' `renderIcon`. */
+    protected get _current(): SortOrder;
+    /** Whether this column has an active header filter. Read by the builds' `renderIcon`. */
+    protected get _filtered(): boolean;
+}
+/**
+ * `MonoTableThCore` — render-mode-agnostic logic for `mono-table-th`, the unified
+ * column-header cell. It declares a column's `field`/`caption`, folds the sort
+ * behavior into a single `:sort.prop` object (`{ order?, noClear?, disabled? }`),
+ * marks a column editable (`editable`), and — with `header-filter` — adds a
+ * DevExtreme-style **header filter**: a funnel icon (or the header's right-click
+ * menu → "Header Filter") opens a panel of the column's distinct values (fetched
+ * via the controller's `distinctValues`, i.e. an OData `$apply=groupby`) with
+ * checkboxes; checking some + Apply calls `dataGrid.setColumnFilter(field, values)`.
+ *
+ * Gestures are fixed, not configurable, and both features split the same way: the
+ * ICON (sort arrow / filter funnel) acts on ONE column, replacing whatever else
+ * was sorted or filtered, while RIGHT-CLICK always opens the menu, whose `Sort ›`
+ * / `Header Filter ›` rows combine columns. One carry-over: once the menu has
+ * started a combination and something is still sorted / filtered, the icons
+ * combine too — the grid remembers the gesture (`sortCombining` /
+ * `columnFilterCombining`) until the last key / filter is gone.
+ *
+ * The standalone `mono-table-sort` element is unchanged and still supported.
+ */
+export declare const MonoTableThCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableThCoreInterface> & T;