@mono-lit/helper 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,76 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { MonoCheckMode } from './mono-data-grid.js';
+import { CheckboxColor, CheckboxCssClass, CheckboxSize } from '../checkbox/checkbox-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Which job this checkbox does. */
+export type TableCheckboxType = 'all' | 'single';
+/** `detail` of the `mno-change` event `<mono-table-checkbox>` emits. */
+export interface TableCheckboxChangeEventDetail<T = any> {
+    /** The state it moved TO. */
+    checked: boolean;
+    /** The row, for `type="single"`; `null` for the select-all. */
+    item: T | null;
+    /** How many rows are selected after the change (a drain fills in later). */
+    count: number;
+}
+export type TableCheckboxChangeEvent<T = any> = CustomEvent<TableCheckboxChangeEventDetail<T>>;
+/** Events emitted by `<mono-table-checkbox>` (feeds the generated Vue types). */
+export interface TableCheckboxEvents {
+    change: TableCheckboxChangeEvent;
+    'mno-change': TableCheckboxChangeEvent;
+    mnoChange: TableCheckboxChangeEvent;
+}
+/** Public surface added by the table-checkbox core mixin. */
+export declare class MonoTableCheckboxCoreInterface extends MonoTableControllerCoreInterface {
+    type: TableCheckboxType;
+    item?: unknown;
+    keyValue?: string | string[];
+    mode: MonoCheckMode;
+    chunk: number;
+    size: CheckboxSize;
+    color: CheckboxColor;
+    disabled: boolean;
+    label: string;
+    /** Secondary line under the label. */
+    sublabel: string;
+    /** The same as `sublabel`, kept for existing code. */
+    description: string;
+    ariaLabelText?: string;
+    cssClass: CheckboxCssClass;
+    cssClassName: string;
+    /** The spinner shown mid-drain — the shadow build swaps in inline SVG. */
+    protected _renderLoadingIcon(): TemplateResult;
+}
+/**
+ * `MonoTableCheckboxCore` — render-mode-agnostic logic for `mono-table-checkbox`,
+ * a checkbox that knows about the grid.
+ *
+ * Two jobs, chosen with `type`:
+ * - **`type="single"`** (default) — one row's checkbox. Give it the row with
+ *   `:item.prop="row"`; it reads and writes `table.check()`.
+ * - **`type="all"`** — the select-all. In `mode="all"` (default) checking it
+ *   drains the SOURCE in `chunk`-sized requests and selects every row the active
+ *   search/filter matches — including rows never fetched for display, which is the
+ *   point of the component. `mode="per-page"` selects the loaded page with no
+ *   request at all. **Every checkbox on the grid is disabled while a drain runs**
+ *   (the selection is still filling in), but only the select-all shows the spinner.
+ *
+ * ```html
+ * <th><mono-table-checkbox type="all" :control-table.prop="table" key-value="Id" /></th>
+ * <td><mono-table-checkbox :control-table.prop="table" :item.prop="row" /></td>
+ * ```
+ *
+ * The `<th>` one canNOT render the `<td>` ones — the library never renders your
+ * `<tbody>` — so both are declared; the row one needs only `:item.prop`.
+ *
+ * **It renders `mono-checkbox`'s markup and classes rather than embedding the
+ * element**, so `size` / `color` / `disabled` / `label` behave identically and the
+ * whole size × color matrix comes from `checkbox.css`. Same trade `mono-table-search`
+ * makes with `mono-input` — and embedding a light `<mono-*>` inside another light
+ * component would steal the parent's Lit-rendered children.
+ *
+ * SSR-safe: the controller is undefined on the server, so it renders an unchecked
+ * shell and touches no DOM.
+ */
+export declare const MonoTableCheckboxCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableCheckboxCoreInterface> & T;

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

@@ -0,0 +1,34 @@
+import { LitElement } from 'lit';
+declare const MonoTableCheckbox_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-checkbox-core.js').MonoTableCheckboxCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-checkbox` (default build, `@mono-lit/helper/ui/table`) — row
+ * selection that knows about the grid.
+ *
+ * The element renders `mono-checkbox`'s classes, whose rules ship in the same
+ * global `dist/ui/index.css` — so `size` / `color` / `disabled` / `label` behave
+ * exactly as they do on a plain `<mono-checkbox>`, with no extra stylesheet. All
+ * logic lives in `MonoTableCheckboxCore`, shared with the shadow build.
+ *
+ * @example
+ * <thead><tr>
+ *   <th><mono-table-checkbox type="all" :control-table.prop="table" key-value="Id" /></th>
+ * </tr></thead>
+ * <tbody>
+ *   <tr v-for="row in rows" :key="row.Id" :data-row-key="row.Id">
+ *     <td><mono-table-checkbox :control-table.prop="table" :item.prop="row" /></td>
+ *   </tr>
+ * </tbody>
+ *
+ * @example
+ * table.check().getAll()   // [{ Id: 8 }, { Id: 12 }, … ]
+ */
+export declare class MonoTableCheckbox extends MonoTableCheckbox_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-checkbox': MonoTableCheckbox;
+    }
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoTableCheckboxShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-checkbox-core.js').MonoTableCheckboxCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-checkbox` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ *
+ * The element renders `mono-checkbox`'s classes, and a shadow root can't see the
+ * page stylesheet, so `checkbox.css` is adopted alongside `table.css` — checkbox
+ * first so table rules can still override. `checkbox.css`'s bare
+ * `mono-checkbox { }` selector simply never matches in here, which is harmless.
+ * (Same arrangement `mono-table-search.shadow` uses for `input.css`.)
+ *
+ * The selection is client-only, so SSR emits an unchecked shell. All logic is
+ * shared via `MonoTableCheckboxCore`.
+ */
+export declare class MonoTableCheckboxShadow extends MonoTableCheckboxShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    /**
+     * `mdi:loading` inlined — a shadow root can't reach the page's `i-mdi-*`
+     * utility CSS, so the light build's icon class would render nothing here.
+     * `fill="currentColor"` keeps it on the box's own icon colour, and the spin
+     * comes from the adopted `checkbox.css` (`[mono-spinner]`), like the box itself.
+     */
+    protected _renderLoadingIcon(): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,87 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** `detail` of the `toggle` / `open` / `close` events `<mono-table-detail>` emits (and of `mno-click`, the kept alias). */
+export interface TableDetailClickEventDetail {
+    /** The state the detail moved TO. */
+    open: boolean;
+    /** `data-row-key` of the row the toggle sits in, when the consumer set one. */
+    rowKey: string | null;
+    /** The chevron click that caused it; absent for `toggle()` / `expandAll()`. */
+    sourceEvent?: Event;
+}
+export type TableDetailClickEvent = CustomEvent<TableDetailClickEventDetail>;
+/** Events emitted by `<mono-table-detail>` (feeds the generated Vue types). */
+export interface TableDetailEvents {
+    toggle: TableDetailClickEvent;
+    open: TableDetailClickEvent;
+    close: TableDetailClickEvent;
+    'mno-click': TableDetailClickEvent;
+    mnoClick: TableDetailClickEvent;
+    'mno-open': TableDetailClickEvent;
+    mnoOpen: TableDetailClickEvent;
+    'mno-close': TableDetailClickEvent;
+    mnoClose: TableDetailClickEvent;
+}
+/** Public surface added by the detail core mixin. */
+export declare class MonoTableDetailCoreInterface extends MonoTableControllerCoreInterface {
+    icon: string;
+    iconExpanded: string;
+    open: boolean;
+    stayOpen: boolean;
+    disabled: boolean;
+    label?: string;
+    toggle(force?: boolean): void;
+    /** The chevron — overridden by the shadow build, which can't use icon classes. */
+    protected _renderIcon(): TemplateResult;
+}
+/**
+ * `MonoTableDetailCore` — render-mode-agnostic logic for `mono-table-detail`, the
+ * expand/collapse chevron for a table row.
+ *
+ * **Shape.** The element itself is *only the toggle*: put it in a `<td>` of the
+ * row you want expandable and keep authoring the `<tr>` yourself. Everything
+ * slotted into it becomes the **panel** — a `<tr class="mono-table-detail-row" mono-detail-row>`
+ * with one `<td colspan="…">` that the element inserts into the `<tbody>`
+ * immediately after its own row while open, and pulls back out when closed. The
+ * `colspan` is recomputed from the parent row's cells on every attach, so it
+ * always spans the whole grid.
+ *
+ * ```html
+ * <tr :data-row-key="row.Id">
+ *   <td>
+ *     <mono-table-detail :control-table.prop="table">
+ *       <p>Notes: {{ row.Note }}</p>
+ *     </mono-table-detail>
+ *   </td>
+ *   <td>{{ row.Name }}</td>
+ * </tr>
+ * ```
+ *
+ * **Why the panel row is built imperatively.** Lit renders through a `<template>`,
+ * and a bare `<tr>` in a non-table parsing context is dropped by the HTML parser —
+ * so the row could never come out of `render()`. It is created with
+ * `document.createElement` instead, which also means the SAME code path serves the
+ * light and the shadow build: in both, the consumer's children are captured off
+ * the host and re-parented into the panel cell (a shadow `<slot>` could not
+ * project content to a row *outside* the host).
+ *
+ * **Content is real DOM the consumer owns**, captured through
+ * `composables/light-slots`, so Vue interpolation (`{{ row.Note }}`), `v-if`
+ * anchors, a whole nested `<table class="mono-table" mono-table>` with its own
+ * `controlMonoTable`, and further nested `<mono-table-detail>` elements all work.
+ * While closed, the captured nodes stay parked inside the (detached) panel cell
+ * rather than orphaned — a captured node with a `null` parent is what crashes
+ * Vue's next patch.
+ *
+ * **Accordion by default.** Opening a row closes the row that was open, scoped to
+ * the bound controller — so a nested grid runs its own accordion without
+ * disturbing the outer one. **`stay-open` is the exemption**: such a row is
+ * skipped by the accordion *and* by `table.detail().collapseAll()`. It is not a
+ * lock — its own chevron still closes it. Mark every row `stay-open` to get
+ * independent panels back.
+ *
+ * SSR-safe: every DOM touch is behind `isServer`, so the server renders just the
+ * collapsed toggle.
+ */
+export declare const MonoTableDetailCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableDetailCoreInterface> & T;

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

@@ -0,0 +1,32 @@
+import { LitElement } from 'lit';
+declare const MonoTableDetail_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-detail-core.js').MonoTableDetailCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-detail` (default build, `@mono-lit/helper/ui/table`) — the
+ * expand/collapse chevron for a table row.
+ *
+ * Drop it into a `<td>` of the row you want expandable; everything you slot into
+ * it becomes the panel, which the element inserts as a full-width `<tr>` right
+ * below that row while open. The chevron uses the global UnoCSS icon classes
+ * (`i-mdi-chevron-right` → `i-mdi-chevron-down`); all other logic lives in
+ * `MonoTableDetailCore`, shared with the shadow build.
+ *
+ * @example
+ * <tr :data-row-key="row.Id">
+ *   <td>
+ *     <mono-table-detail :control-table.prop="table" @toggle="onToggle">
+ *       <p>Notes: {{ row.Note }}</p>
+ *     </mono-table-detail>
+ *   </td>
+ *   <td>{{ row.Name }}</td>
+ * </tr>
+ */
+export declare class MonoTableDetail extends MonoTableDetail_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-detail': MonoTableDetail;
+    }
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoTableDetailShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-detail-core.js').MonoTableDetailCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-detail` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ *
+ * The toggle renders into a real shadow root, with the two chevrons inlined as SVG
+ * (`mdi:chevron-right` / `mdi:chevron-down`) because a shadow root can't reach the
+ * page-level icon utility CSS — the same trade the sort/search shadow builds make.
+ * A consumer who sets a custom `icon` / `icon-expanded` class gets the class span
+ * from the core — and the generated icon rules are adopted into this root so the
+ * class actually paints, the same way `mono-table-empty` does it. Without that
+ * the span is there and empty, which is what a `+` / `−` toggle looked like in
+ * the shadow tab beside a light tab that showed both glyphs.
+ *
+ * The **panel row is light DOM by construction**: it is inserted into the
+ * consumer's own `<tbody>`, outside this element's shadow root, so it is styled by
+ * the global `dist/ui/index.css` in both builds. That is already true of the
+ * `<table class="mono-table" mono-table>` around it, so nothing extra is asked of the
+ * consumer here.
+ *
+ * Shares all behaviour via `MonoTableDetailCore`.
+ */
+export declare class MonoTableDetailShadow extends MonoTableDetailShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /** Only when a CUSTOM class is in play — the defaults are inlined SVG. */
+    private _maybeAdoptIcons;
+    protected _renderIcon(): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+import { MonoTableController } from './mono-data-grid.js';
+/** `detail` of the `reload` event `<mono-table-empty>` emits when its button is pressed. */
+export interface TableEmptyReloadEventDetail {
+    grid: MonoTableController;
+}
+export type TableEmptyReloadEvent = CustomEvent<TableEmptyReloadEventDetail>;
+/** Events emitted by `<mono-table-empty>` (feeds the generated Vue types). */
+export interface TableEmptyEvents {
+    reload: TableEmptyReloadEvent;
+    'mno-reload': TableEmptyReloadEvent;
+    mnoReload: TableEmptyReloadEvent;
+}
+/** Public surface added by the empty-state core mixin. */
+export declare class MonoTableEmptyCoreInterface extends MonoTableControllerCoreInterface {
+    icon: string;
+    title: string;
+    subtitle: string;
+    reload: boolean;
+    reloadLabel: string;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+    /** Set by each build once `slot="body"` is known to hold something. */
+    protected _hasBodySlot: boolean;
+    /** Overridden by the shadow build to emit a real `<slot>`. */
+    protected _renderBodySlot(): TemplateResult;
+    protected _renderProps(): TemplateResult;
+    protected _renderIcon(): TemplateResult | typeof nothing;
+}
+/**
+ * `MonoTableEmptyCore` — render-mode-agnostic logic for `mono-table-empty`, the
+ * message shown over a grid that came back with no rows.
+ *
+ * It is `mono-table-loading`'s pair: same `<caption>` host, same overlay geometry,
+ * same controller binding — one covers the grid while a query runs, this one
+ * covers it when the query returned nothing. Everything they share lives in
+ * `table-overlay.ts`.
+ *
+ * **When it shows.** With a controller bound: only once that controller has
+ * settled at least once (`hasLoaded`) AND has no rows AND is not loading. The
+ * `hasLoaded` gate is the load-bearing one — a fresh controller reads
+ * `items: [], loading: false`, which is indistinguishable from "loaded and
+ * genuinely empty", so without it every table would flash "No data" on mount
+ * before its first request had even been made.
+ *
+ * With NO controller bound it shows unconditionally, because then the consumer is
+ * driving it with `v-if` / `v-show` and an element that hid itself would simply
+ * never appear.
+ *
+ * **What it shows.** `icon`, then `title`, then `subtitle`, then a reload button —
+ * each omitted when its prop is empty. A `slot="body"` replaces all four, so a
+ * consumer can put arbitrary markup (or a mono component) in the same box and
+ * keep the placement and centring for free.
+ *
+ * SSR-safe: all DOM work is guarded behind `isServer`.
+ */
+export declare const MonoTableEmptyCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableEmptyCoreInterface> & T;

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

@@ -0,0 +1,35 @@
+import { LitElement } from 'lit';
+declare const MonoTableEmpty_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-empty-core.js').MonoTableEmptyCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-empty` (default build, `@mono-lit/helper/ui/table`).
+ *
+ * The message shown over a grid that came back with no rows — `mono-table-loading`'s
+ * pair, and placed the same way:
+ *
+ * ```html
+ * <caption>
+ *   <mono-table-empty :control-table.prop="table" title="No people found" />
+ * </caption>
+ * ```
+ *
+ * Everything else — when it shows, what it shows, the overlay geometry — is in
+ * `MonoTableEmptyCore`. This build only adds the light-DOM half of `slot="body"`:
+ * the consumer's markup is captured out of the host before the first render and
+ * re-placed into the rendered region afterwards, because a light build renders
+ * 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;
+    connectedCallback(): void;
+    private _captureSlots;
+    protected updated(changed: Map<string, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-empty': MonoTableEmpty;
+    }
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoTableEmptyShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-empty-core.js').MonoTableEmptyCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-empty` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ *
+ * Renders the message into a real shadow root; the `host: 'mono-table-empty'`
+ * rewrite turns the overlay's element-selector rules into `:host` so the shadow
+ * sheet self-contains its styling. Emptiness is client-only state, so SSR emits an
+ * inert (hidden) host. Shares all logic via `MonoTableEmptyCore`.
+ *
+ * Two things this build has to do differently:
+ *
+ * - **`slot="body"` is a native `<slot>`**, not a captured region, and its
+ *   presence is read from `assignedNodes()` (DSD assigns at parse time, so
+ *   `slotchange` does not fire on upgrade — `firstUpdated` has to look once).
+ * - **An `i-*` icon class cannot paint here.** UnoCSS generates those as a mask
+ *   on the PAGE stylesheet, which does not cross the shadow boundary, so the
+ *   span would render as a blank box. `adoptIconStyles` copies the page's
+ *   generated icon rules into a sheet this root adopts. An emoji or plain-text
+ *   icon needs none of that — it is just text — which is exactly why the core's
+ *   two-shape branch exists.
+ */
+export declare class MonoTableEmptyShadow extends MonoTableEmptyShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    protected firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _maybeAdoptIcons;
+    private _syncBodySlot;
+    /**
+     * The body region as a real `<slot>`.
+     *
+     * `data-empty` collapses it while the props are in play rather than dropping it
+     * — a `<slot>` that is not in the tree has no assigned nodes, so removing it
+     * would make `_syncBodySlot` permanently report "no body" and the override
+     * could never turn on.
+     */
+    protected _renderBodySlot(): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,84 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { MonoErrorBehaviour, MonoTableError } from './mono-data-grid.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** `detail` of the `close` event `<mono-table-error>` emits when its × is pressed. */
+export interface TableErrorCloseEventDetail {
+    /** The text that was showing. */
+    message: string;
+    /** The controller error it stood for, if any. */
+    error: MonoTableError | null;
+}
+/** `detail` of the `reload` event `<mono-table-error>` emits when its ↻ is pressed. */
+export interface TableErrorReloadEventDetail {
+    error: MonoTableError | null;
+}
+export type TableErrorCloseEvent = CustomEvent<TableErrorCloseEventDetail>;
+export type TableErrorReloadEvent = CustomEvent<TableErrorReloadEventDetail>;
+/** Events emitted by `<mono-table-error>` (feeds the generated Vue types). */
+export interface TableErrorEvents {
+    close: TableErrorCloseEvent;
+    reload: TableErrorReloadEvent;
+    'mno-close': TableErrorCloseEvent;
+    mnoClose: TableErrorCloseEvent;
+    'mno-reload': TableErrorReloadEvent;
+    mnoReload: TableErrorReloadEvent;
+}
+/** Public surface added by the error-bar core mixin. */
+export declare class MonoTableErrorCoreInterface extends MonoTableControllerCoreInterface {
+    message: string;
+    dismissible: boolean;
+    closeLabel: string;
+    behaviour: MonoErrorBehaviour;
+    reload: boolean;
+    reloadLabel: string;
+    protected renderIcon(name: 'close' | 'refresh'): TemplateResult;
+}
+/**
+ * `MonoTableErrorCore` — render-mode-agnostic logic for `mono-table-error`, the
+ * red bar shown under the header when a request fails.
+ *
+ * Unlike `mono-table-loading` and `mono-table-empty`, which paint OVER the grid,
+ * this one is a real row in it, taking up honest height directly below the
+ * header the way DevExtreme's error row does. The consumer writes that row —
+ * `<tr><td colspan><mono-table-error/></td></tr>` — and the element ADOPTS it
+ * (`ensureRowHost`): the row class the padding reset keys on, the zebra-skip
+ * marker and a live `colspan` are stamped on, so the hand-written form needs
+ * nothing but the two tags. Dropped bare into `<tbody>` it still wraps itself,
+ * but that is invalid HTML — Vue warns, and it does not survive SSR — so it is
+ * the fallback, not the taught form.
+ *
+ * **What it shows.** `message` if you set one — an explicit message is an
+ * instruction, and it wins for as long as it is set. Otherwise the controller's
+ * last caught error (`MonoTableController.error`), whose text comes from the
+ * error itself rather than from a hardcoded string.
+ *
+ * **A failure clears the rows** (`behaviour="clear-list"`, the default): the
+ * controller empties `items` when it records the error, so a rejected filter
+ * never leaves the previous filter's rows under the bar. `"keep-list"` keeps
+ * them. The setting is pushed to the controller (`setErrorBehaviour`), so it
+ * holds whether or not this element is the one on screen.
+ *
+ * **Reload** (`reload`, default `true`): a ↻ beside the × that re-runs the
+ * failed query (`table.reload()`). The bar stays until that succeeds.
+ *
+ * **Dismiss hides THIS element only.** The controller keeps its error, so
+ * anything else bound to the same table still agrees that it happened. What
+ * comes back is the next *failure*, not the next different message: the element
+ * remembers the error object it dismissed, and the controller mints a fresh one
+ * per failure, so an identical repeat error re-shows.
+ *
+ * **It stays in view.** The row is table-wide, and on a table wider than its
+ * `.mono-table-scroll` that put the text at the far left and the ✕ / ↻ past the
+ * right edge — invisible until you scrolled for them. So the bar inside the row
+ * is `position: sticky; left: 0` at exactly the scrollport's width (`100cqw`,
+ * the same container-query trick the loading spinner centres with — pure CSS in
+ * `table.css`). Vertically it follows the HEADER: under `mono-table-sticky-head`
+ * the row's cell is sticky too, `top` = the measured `<thead>` height, which this
+ * element publishes as `--mono-table-error-head` on the `<table>` and keeps
+ * fresh with a `ResizeObserver` (a banded two-row header, a caption that wraps).
+ * A header that scrolls away takes the bar with it — it belongs to those rows.
+ *
+ * SSR-safe: all DOM work is guarded behind `isServer`.
+ */
+export declare const MonoTableErrorCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableErrorCoreInterface> & T;

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

@@ -0,0 +1,28 @@
+import { LitElement } from 'lit';
+declare const MonoTableError_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-error-core.js').MonoTableErrorCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-error` (default build, `@mono-lit/helper/ui/table`).
+ *
+ * The red bar shown under the header when a request fails:
+ *
+ * ```html
+ * <tbody>
+ *   <tr><td colspan="3"><mono-table-error :control-table.prop="table" /></td></tr>
+ *   <tr v-for="…">…</tr>
+ * </tbody>
+ * ```
+ *
+ * All the logic is in `MonoTableErrorCore`. This build adds nothing but the tag
+ * and the stylesheet — the close glyph is the global `i-mdi-close` utility class,
+ * 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 {
+    interface HTMLElementTagNameMap {
+        'mono-table-error': MonoTableError;
+    }
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoTableErrorShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-error-core.js').MonoTableErrorCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-error` (SSR build, `@mono-lit/helper/ui/shadow/table`).
+ *
+ * Renders the bar into a real shadow root; the `host: 'mono-table-error'` rewrite
+ * turns the element-selector rules into `:host` so the shadow sheet self-contains
+ * its styling. A load error is client-only state, so SSR emits an inert host.
+ * Shares all logic via `MonoTableErrorCore`.
+ */
+export declare class MonoTableErrorShadow extends MonoTableErrorShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    /**
+     * Inline SVG — the global `.mono-icon` / `i-mdi-close` UnoCSS rule cannot reach
+     * a shadow root, so the class the light build uses would paint a blank box
+     * here. Same glyph, same split as `mono-modal` / `mono-drawer`.
+     */
+    protected renderIcon(name: 'close' | 'refresh'): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { LitElement } from 'lit';
+import { MonoTableControllerCoreInterface } from './table-controller-core.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public surface added by the info core mixin. */
+export declare class MonoTableInfoCoreInterface extends MonoTableControllerCoreInterface {
+    template: string;
+}
+/**
+ * `MonoTableInfoCore` — render-mode-agnostic logic for `mono-table-info`: a
+ * read-only summary line (`Showing {from}–{to} of {total}`) driven by the
+ * controller. No slots, no icons — light and shadow share the full `render()`.
+ */
+export declare const MonoTableInfoCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoTableInfoCoreInterface> & T;

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

@@ -0,0 +1,19 @@
+import { LitElement } from 'lit';
+declare const MonoTableInfo_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-info-core.js').MonoTableInfoCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-table-info` (default build, `@mono-lit/helper/ui/table`). Renders
+ * into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`). All logic lives in `MonoTableInfoCore`; the shadow build
+ * (`@mono-lit/helper/ui/shadow/table`) shares the mixin. Both register the same tag,
+ * so a document loads only one.
+ */
+export declare class MonoTableInfo extends MonoTableInfo_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-table-info': MonoTableInfo;
+    }
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+declare const MonoTableInfoShadow_base: import('../../composables/hybird-prop').Constructor<import('./mono-table-info-core.js').MonoTableInfoCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-table-info` (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 `MonoTableInfoCore`. Registers the `mono-shadow-*`
+ * tag — DISTINCT from the light `<mono-table-info>` — so both can coexist.
+ */
+export declare class MonoTableInfoShadow extends MonoTableInfoShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+}
+export {};