@mono-lit/helper 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,152 @@
+import { MonoTableController, MonoGridSource, MonoDataGridOptions, MonoTableProps, MonoCheckLimits } from '../table/mono-data-grid.js';
+import { MonoEventProps } from '../../composables/element-props';
+import { DropdownTableEvents } from './dropdown-table-types';
+/** One resolved selection (key + display text + the row it came from). */
+export interface MonoDropdownItem<T = any> {
+    key: unknown;
+    text: string;
+    data: T | undefined;
+}
+/**
+ * Central props for a dropdown-table, in the same shape as
+ * `monoDataGrid({ props })`.
+ *
+ * Everything except `dropdownTable` targets the PANEL and is forwarded verbatim
+ * to the wrapped grid, so `th` / `search` / `paging` behave exactly as they do
+ * on a plain table. `dropdownTable` is the extra slot: the closed field itself.
+ */
+export interface MonoDropdownProps extends MonoTableProps {
+    /**
+     * Props for the `<mono-dropdown-table>` field element, plus its events as
+     * `on<Event>` keys (`onChange`, `onOpen`, `onClose`, …) attached as listeners.
+     */
+    dropdownTable?: Record<string, unknown> & MonoEventProps<DropdownTableEvents>;
+}
+export interface MonoDataDropdownOptions extends MonoDataGridOptions {
+    /** Row key field (default `'Id'`). Also forwarded to the inner grid. */
+    keyExpr?: string;
+    /** Display text — a field name or a `(row) => string`. Defaults to `keyExpr`. */
+    displayExpr?: string | ((row: any) => string);
+    /** Multi-select (array value) vs single (scalar). */
+    multiple?: boolean;
+    /**
+     * Most rows the user can select in multi mode (unset = unlimited). Enforced by
+     * the grid's check store, so a row click, the keyboard, `<mono-table-checkbox>`
+     * (row and `type="all"`) and `selectAll()` all stop at it — a pick past the cap
+     * is rejected and the checkbox un-ticks itself. `setValue()` is not capped.
+     * The element's own `max` / `chip.max`, when set, override this.
+     */
+    max?: number;
+    /**
+     * Fewest rows the user can leave selected (unset = 0). Un-ticking at the floor
+     * is rejected; `clear()` keeps the first `min`. Overridden by the element's
+     * `min` / `chip.min` when set.
+     */
+    min?: number;
+    /** Central element props — the grid slots plus `dropdownTable`. */
+    props?: MonoDropdownProps;
+    /**
+     * A ref the dropdown writes a `props()` snapshot into on every change. The
+     * DROPDOWN owns this, not the inner grid — the snapshot has to carry
+     * `dropdownTable` alongside the grid slots, so a template can drive both the
+     * field and its header loop from one object.
+     */
+    state?: {
+        value: MonoDropdownProps | undefined;
+    };
+}
+/**
+ * The dropdown controller — wraps a {@link monoDataGrid} (`.grid`, bind the panel's
+ * `mono-table-*` to it) and adds selection, `value`, and key→label display
+ * resolution. Mutated in place; read after `subscribe` fires (coalesced).
+ */
+export interface MonoDropdownController<T = any> {
+    /** The inner table controller. Bind `mono-table-*` with `:control-table.prop="dd.table"`
+     *  (alias `:data-grid.prop="dd.grid"`). */
+    readonly grid: MonoTableController<T>;
+    /** Alias of {@link grid} — the inner `controlMonoTable`. Preferred in new code. */
+    readonly table: MonoTableController<T>;
+    /**
+     * Central element props — the grid's slots plus `dropdownTable` (the field
+     * itself). Mirrors `table.props()`; a stable read, mutated in place.
+     */
+    props(): MonoDropdownProps;
+    readonly multiple: boolean;
+    /** Selected value: scalar (single) or array (multi). Setting resolves display. */
+    value: unknown;
+    /** Whether the dropdown panel is open. */
+    open: boolean;
+    /** Assignable sink fired on INTERNAL value changes (toggle/remove/clear), not `setValue`. */
+    onValueChange: ((value: unknown) => void) | null;
+    isSelected(key: unknown): boolean;
+    /**
+     * The selection limits in force — the element's `max` / `min` when it set
+     * them, else the controller options'. Read `atMax` / `atMin` from
+     * `table.check()` for the live state.
+     */
+    limits(): MonoCheckLimits;
+    /**
+     * The element pushes its effective `max` / `min` here. `undefined` for a key
+     * means "the element has no opinion" and the controller option applies again.
+     */
+    setLimits(limits: MonoCheckLimits): void;
+    toggleRow(key: unknown, rowData?: T): void;
+    removeKey(key: unknown): void;
+    clear(): void;
+    /**
+     * Select every row the source returns for the CURRENT filter + search — the
+     * dropdown's counterpart to the table's `<mono-table-checkbox type="all">`.
+     * Drains through `table.getData()` and primes the display cache from the drained
+     * rows, so it costs the drain and no resolution requests. Fills only the room
+     * `max` leaves.
+     * No-op unless `multiple`, and re-entrant calls are ignored while one is running.
+     * `clear()` is the inverse.
+     *
+     * Read {@link selectAllPending} to show a loading state while it runs.
+     */
+    selectAll(): Promise<void>;
+    /**
+     * Whether a {@link selectAll} drain is in flight — the dropdown's equivalent of
+     * the table's `check().pending`. Flips true (with a notify) BEFORE the first
+     * request, so a subscriber can render the spinner before the network blocks.
+     *
+     * Unlike the table, a repeat `selectAll()` re-drains: the table memoises its last
+     * drain, but that memo is invalidated against grid internals (row-set version,
+     * search terms) this controller does not own, and a stale selection is a worse
+     * failure than a redundant fetch.
+     */
+    readonly selectAllPending: boolean;
+    /** The selected items (ordered), resolved to `{ key, text, data }`. */
+    selectedItems(): Array<MonoDropdownItem<T>>;
+    /** Joined display text of the current selection. */
+    displayText(): string;
+    /**
+     * Replace the selection. Pass `rows` when you already hold the matching row
+     * objects (a drain, a paged read) to seed the display cache and skip the
+     * `in`-filter round trips `resolveSelected` would otherwise make.
+     *
+     * Does NOT emit — this is the inbound path the element pushes `modelValue` down.
+     * Use {@link selectAll} or {@link toggleRow} for a change that should notify.
+     */
+    setValue(next: unknown, rows?: readonly T[]): void;
+    setOpen(next: boolean): void;
+    /** Fetch + cache display text for any selected keys not yet resolved. */
+    resolveSelected(): Promise<void>;
+    subscribe(cb: () => void): () => void;
+    bind(source: MonoGridSource<T> | T[] | null): void;
+    dispose(): void;
+}
+/**
+ * `monoDataDropdown` — the composable that owns all the grid-dropdown "magic":
+ * selection (single/multi), the bound `value`, and resolving a selected KEY to its
+ * display TEXT. The options table is the reused headless {@link monoDataGrid}
+ * exposed as `.grid`, so search / sort / paging / header-filter all work by binding
+ * the panel's `mono-table-*` helpers to it. Pair with `<mono-dropdown-table>`.
+ *
+ * Display resolution uses `store.load({ filter })` ONLY — never `byKey` (which
+ * caches per key and would hide updated rows) — with an `in`-filter (+ OR-chain
+ * fallback) for a remote source, or the array source's `data()` for a local one.
+ */
+/** Renamed "control" alias of {@link monoDataDropdown} (no breaking change — both work). */
+export { monoDataDropdown as controlMonoDataDropdown };
+export declare function monoDataDropdown<T = any>(source?: MonoGridSource<T> | T[] | null, opts?: MonoDataDropdownOptions): MonoDropdownController<T>;

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

@@ -0,0 +1,46 @@
+import { LitElement } from 'lit';
+declare const MonoDropdownTable_base: import('../../composables/hybird-prop').Constructor<import('./dropdown-table-core.js').MonoDropdownTableCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-dropdown-table` (default build, `@mono-lit/helper/ui/dropdown-table`).
+ * A dropdown whose panel holds a **native `<table>`** for picking row(s), driven by
+ * a {@link monoDataDropdown} controller bound with `:data-dropdown.prop`.
+ *
+ * Light-DOM slot strategy (mirrors `mono-dropdown`): the consumer's children are
+ * captured by their `slot` attribute in `connectedCallback` (`search` / `footer` /
+ * default → the table body), the template renders empty `[data-mono-slot]` targets,
+ * and the captured nodes are re-appended in `updated()` — falling back to the popup
+ * portal once the panel is relocated to `<body>`. The captured nodes are MOVED (not
+ * cloned), so a Vue-authored `<table>` keeps its reactivity.
+ *
+ * @example
+ * <mono-dropdown-table :data-dropdown.prop="dd" placeholder="Pick a department" clearable>
+ *   <mono-table-search :data-grid.prop="dd.grid" slot="search" />
+ *   <table mono-table>
+ *     <thead>…mono-table-th…</thead>
+ *     <tbody>
+ *       <tr v-for="r in rows" :key="r.Id" :data-row-key="String(r.Id)">
+ *         <td>{{ r.Code }}</td><td>{{ r.Nama }}</td>
+ *       </tr>
+ *     </tbody>
+ *   </table>
+ *   <mono-table-paging :data-grid.prop="dd.grid" slot="footer" />
+ * </mono-dropdown-table>
+ */
+export declare class MonoDropdownTable extends MonoDropdownTable_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _slotSearch;
+    private _slotBody;
+    private _slotFooter;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-dropdown-table': MonoDropdownTable;
+    }
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoDropdownTableShadow_base: import('../../composables/hybird-prop').Constructor<import('./dropdown-table-core.js').MonoDropdownTableCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-shadow-dropdown-table` (SSR build, `@mono-lit/helper/ui/shadow/dropdown-table`).
+ * The FIELD renders in a real shadow root (chips painted by the component's own sheet);
+ * the panel's regions are native `<slot>`s into which the consumer's LIGHT-DOM
+ * `<table>` + `mono-table-*` project — so those stay light, exactly as in the light
+ * build. The popup controller auto-detects the shadow host and does NOT portal; the
+ * core's `_positionPanel` places the fixed panel at the trigger. Shares all logic via
+ * `MonoDropdownTableCore`.
+ */
+export declare class MonoDropdownTableShadow extends MonoDropdownTableShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    private _onSlotChange;
+    firstUpdated(changed: Map<string, unknown>): void;
+    /** Mark a region whose `<slot>` has no assigned content `mono-empty` (light uses `:empty`). */
+    private _scanRegions;
+    /** Native `<slot>` per region (body = the default unnamed slot for the `<table>`). */
+    protected _renderRegion(cls: string, name: string): TemplateResult;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { LitElement, TemplateResult } from 'lit';
+import { FileUploadCssClass, FileUploadItem, FileUploadValidationState, FileUploadVariant } from './file-upload-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoFileUploadCoreInterface {
+    label: string;
+    helperText: string;
+    /** Dropzone headline. `placeholder` is the old name, kept as an alias. */
+    title: string;
+    /** Dropzone secondary line. `subtext` is the old name, kept as an alias. */
+    subtitle: string;
+    /** @deprecated alias of `title` */
+    placeholder: string;
+    /** @deprecated alias of `subtitle` */
+    subtext: string;
+    icon: string;
+    removeIcon: string;
+    accept: string;
+    multiple: boolean;
+    disabled: boolean;
+    required: boolean;
+    dragdrop: boolean;
+    maxFileSize: number;
+    maxFiles: number;
+    modelValue: FileUploadItem[];
+    cssClass: FileUploadCssClass;
+    variant: FileUploadVariant;
+    validationState: FileUploadValidationState;
+    validationMessage: string;
+    clear(): void;
+    protected _hasIconSlot: boolean;
+    protected _hasTitleSlot: boolean;
+    protected _hasSubtitleSlot: boolean;
+    protected _inputEl: HTMLInputElement;
+    protected _cls(base: string, key: keyof FileUploadCssClass): string;
+    protected get _wrapperClasses(): string;
+    protected get _subtitleClasses(): string;
+    protected _useIconSlots(): boolean;
+    protected _renderDropzoneIcon(): TemplateResult;
+    protected _renderTitle(): TemplateResult;
+    protected _renderSubtitle(): TemplateResult;
+    protected _renderDefaultGlyph(): TemplateResult;
+    protected _renderRemoveIcon(): TemplateResult;
+    protected _renderThumbGlyph(item: FileUploadItem): TemplateResult;
+}
+/**
+ * `MonoFileUploadCore` — all render-mode-agnostic logic for `mono-file-upload`:
+ * reactive props (incl. SSR boolean + modelValue-array coercion), hybrid aliases,
+ * camelCase attribute fallbacks, the file pipeline (validate / add / drag-drop /
+ * remove / clear), the `mno-change`/`mno-remove`/`mno-error` events, and the
+ * dropzone/list/message `render()`. Icon rendering goes through overridable hooks
+ * (`_renderDropzoneIcon`/`_renderDefaultGlyph`/`_renderRemoveIcon`/
+ * `_renderThumbGlyph`) — the light build keeps `data-mono-slot` + `i-mdi-*` iconify
+ * classes; the shadow build uses native `<slot>` + inline SVG (iconify can't paint
+ * inside a shadow root).
+ *
+ * SSR-safe: no `document`/`window` access at module/ctor scope; the file pipeline
+ * and `_inputEl` (`@query`) only run client-side from user interaction.
+ */
+export declare const MonoFileUploadCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoFileUploadCoreInterface> & T;

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

@@ -0,0 +1,145 @@
+import { VisibilityProps } from '../../composables/visibility';
+export type FileUploadVariant = 'default' | 'compact';
+export type FileUploadValidationState = 'default' | 'valid' | 'invalid' | 'warning';
+export type FileUploadAction = 'add' | 'remove' | 'replace' | 'clear';
+/**
+ * Per-element class overrides. Each key maps to one of the rendered internal
+ * elements; the supplied class string is appended to the element's base class.
+ */
+export interface FileUploadCssClass {
+    root?: string;
+    label?: string;
+    required?: string;
+    dropzone?: string;
+    icon?: string;
+    title?: string;
+    /** The secondary dropzone line. */
+    subtitle?: string;
+    /** @deprecated Old key of `subtitle`, still applied to the same element. */
+    subtext?: string;
+    input?: string;
+    list?: string;
+    item?: string;
+    thumb?: string;
+    file?: string;
+    name?: string;
+    meta?: string;
+    remove?: string;
+    message?: string;
+}
+export interface FileUploadItem {
+    id: string;
+    file?: File;
+    name: string;
+    size: number;
+    type: string;
+    previewUrl?: string;
+}
+export type FileUploadModelEventDetail = {
+    modelValue: FileUploadItem[];
+    currentValue: FileUploadItem[];
+    oldValue: FileUploadItem[];
+    files: FileUploadItem[];
+    addedFiles: FileUploadItem[];
+    removedFile?: FileUploadItem;
+    action: FileUploadAction;
+    sourceEvent?: Event;
+};
+export type FileUploadRemoveEventDetail = {
+    modelValue: FileUploadItem[];
+    currentValue: FileUploadItem[];
+    oldValue: FileUploadItem[];
+    files: FileUploadItem[];
+    removedFile: FileUploadItem;
+    action: 'remove';
+    sourceEvent?: Event;
+};
+export type FileUploadErrorEventDetail = {
+    message: string;
+    reason: 'max-file-size' | 'max-files';
+    file?: File;
+    maxFileSize?: number;
+    maxFiles?: number;
+    sourceEvent?: Event;
+};
+export type FileUploadModelEvent = CustomEvent<FileUploadModelEventDetail>;
+export type FileUploadRemoveEvent = CustomEvent<FileUploadRemoveEventDetail>;
+export type FileUploadErrorEvent = CustomEvent<FileUploadErrorEventDetail>;
+export interface FileUploadProps extends VisibilityProps {
+    /** Field label shown above the dropzone. */
+    label?: string;
+    /** Helper text shown below the dropzone. */
+    helperText?: string;
+    'helper-text'?: string;
+    helpertext?: string;
+    /**
+     * Primary prompt text inside the dropzone. `slot="title"` replaces it.
+     * Default `'Klik atau seret file ke sini'`.
+     */
+    title?: string;
+    /**
+     * Secondary hint text inside the dropzone. `slot="subtitle"` replaces it.
+     * Default `'Pilih file untuk diunggah'`.
+     */
+    subtitle?: string;
+    /** @deprecated Old name of `title`, still accepted. */
+    placeholder?: string;
+    /** @deprecated Old name of `subtitle`, still accepted. */
+    subtext?: string;
+    /** Accepted file types for the file input. */
+    accept?: string;
+    /**
+     * Dropzone icon. An iconify utility class (e.g. `i-mdi-cloud-upload`) renders
+     * the icon; any other string renders as text/emoji. A `slot="icon"` child
+     * takes priority over this prop.
+     */
+    icon?: string;
+    /** Remove (✕) button icon — iconify class or text. */
+    removeIcon?: string;
+    'remove-icon'?: string;
+    removeicon?: string;
+    /** Allows selecting multiple files at once. */
+    multiple?: boolean;
+    /** Disables interaction and dims the component. */
+    disabled?: boolean;
+    /** Marks the field as required with an indicator. */
+    required?: boolean;
+    /** Enables drag-and-drop file selection. */
+    dragdrop?: boolean;
+    /** Maximum allowed size per file, in bytes. */
+    maxFileSize?: number;
+    'max-file-size'?: number;
+    maxfilesize?: number;
+    /** Maximum number of files allowed. */
+    maxFiles?: number;
+    'max-files'?: number;
+    maxfiles?: number;
+    /** Two-way bound list of selected files. */
+    modelValue?: FileUploadItem[];
+    'model-value'?: FileUploadItem[];
+    modelvalue?: FileUploadItem[];
+    /** Layout style: default or compact. */
+    variant?: FileUploadVariant;
+    /** Validation state styling the component. */
+    validationState?: FileUploadValidationState;
+    'validation-state'?: FileUploadValidationState;
+    validationstate?: FileUploadValidationState;
+    /** Validation message shown below the dropzone. */
+    validationMessage?: string;
+    'validation-message'?: string;
+    validationmessage?: string;
+    /** Per-element class overrides for internal parts. */
+    cssClass?: FileUploadCssClass;
+    'css-class'?: FileUploadCssClass;
+}
+export interface FileUploadEvents {
+    change: FileUploadModelEvent;
+    remove: FileUploadRemoveEvent;
+    error: FileUploadErrorEvent;
+    'mno-change': FileUploadModelEvent;
+    mnoChange: FileUploadModelEvent;
+    'mno-remove': FileUploadRemoveEvent;
+    mnoRemove: FileUploadRemoveEvent;
+    'mno-error': FileUploadErrorEvent;
+    mnoError: FileUploadErrorEvent;
+}

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

@@ -0,0 +1,16 @@
+import { FileUploadValidationState, FileUploadVariant, FileUploadItem } from './file-upload-types.js';
+export declare function validateFileUploadProps(props: {
+    variant?: FileUploadVariant;
+    validationState?: FileUploadValidationState;
+}): boolean;
+export { isIconifyClass } from '../../composables/icon.js';
+export declare function formatFileSize(size: number): string;
+/**
+ * Pick a default file-type icon. Returns an MDI iconify utility class
+ * (`i-mdi-*`, resolved by UnoCSS preset-icons) — see
+ * https://icon-sets.iconify.design/mdi/ . The render layer paints these as a
+ * masked SVG via {@link isIconifyClass}. The full set is safelisted in
+ * `uno.config.ts` so the CSS ships in `dist/ui/index.css`.
+ */
+export declare function getFileIcon(type: string, name: string): string;
+export declare function createUploadItem(file: File): FileUploadItem;

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

@@ -0,0 +1,4 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoFileUpload } from './mono-file-upload.js';
+export type { FileUploadItem, FileUploadProps, FileUploadEvents, FileUploadVariant, FileUploadValidationState, } from './file-upload-types.js';
+export { validateFileUploadProps, formatFileSize, getFileIcon, createUploadItem, } from './file-upload-utils.js';

package/dist/src/components/file-upload/index.shadow.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoFileUploadShadow } from './mono-file-upload.shadow.js';
+export { MonoFileUploadCore } from './file-upload-core.js';
+export type { FileUploadItem, FileUploadProps, FileUploadEvents, FileUploadVariant, FileUploadValidationState, } from './file-upload-types.js';
+export { validateFileUploadProps, formatFileSize, getFileIcon, createUploadItem, } from './file-upload-utils.js';

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

@@ -0,0 +1,33 @@
+import { LitElement } from 'lit';
+declare const MonoFileUpload_base: import('../../composables/hybird-prop').Constructor<import('./file-upload-core.js').MonoFileUploadCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-file-upload` (default build, `@mono-lit/helper/ui/file-upload`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`). The `slot="icon"` / `slot="title"` / `slot="subtitle"`
+ * dropzone parts use the light-DOM strategy: the child is captured in
+ * `connectedCallback`, the template renders an empty `[data-mono-slot="…"]`
+ * target, and the node is re-placed in `updated()`.
+ * All render-mode-agnostic logic + the default `i-mdi-*` iconify rendering live in
+ * `MonoFileUploadCore`. The shadow build (`@mono-lit/helper/ui/shadow/file-upload`)
+ * shares the mixin but uses native `<slot>` + inline SVG. Both register
+ * `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;
+    private _parked?;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /** Move light-DOM `slot="icon|title|subtitle"` children out for placement into their regions. */
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-file-upload': MonoFileUpload;
+    }
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { LitElement, TemplateResult } from 'lit';
+import { FileUploadItem } from './file-upload-types.js';
+declare const MonoFileUploadShadow_base: import('../../composables/hybird-prop').Constructor<import('./file-upload-core.js').MonoFileUploadCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-file-upload` (the opt-in SSR build,
+ * `@mono-lit/helper/ui/shadow/file-upload`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`mono-file-upload`→`:host`). The
+ * dropzone (label / title / subtitle / icon / `<input type=file>`) renders
+ * server-side; the file LIST is inherently client-only (`File`/blob previews).
+ * Icons are inline SVG (the `i-mdi-*` UnoCSS classes can't paint inside a shadow
+ * root): default dropzone glyph, the remove ✕, and a generic file-type thumb glyph
+ * (image files still show their `previewUrl`). A native `<slot name="icon">`
+ * overrides the dropzone icon; `<slot name="title">` / `<slot name="subtitle">`
+ * override the two text lines (the props are their fallback content). Custom iconify `icon`/`removeIcon` PROP values
+ * degrade to invisible in shadow (use the slot). Interactivity (picker click /
+ * drag-drop / remove) needs the first client update to flush — hence the
+ * defer-hydration poll. Shares all logic with the light build via
+ * `MonoFileUploadCore`; both register `mono-file-upload`, so a document loads one.
+ */
+export declare class MonoFileUploadShadow extends MonoFileUploadShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    /**
+     * Slot presence from `assignedNodes()` (DSD assigns slotted content at parse
+     * time, so `slotchange` may never fire after upgrade). Only ASSIGNED nodes
+     * count — `flatten` would return the prop fallback for an empty slot.
+     */
+    private _slotHas;
+    private _scanSlots;
+    protected _useIconSlots(): boolean;
+    /** Native slot; the `title` prop is its fallback content (paints with no JS). */
+    protected _renderTitle(): TemplateResult;
+    /** Native slot; the `subtitle` prop is its fallback content. */
+    protected _renderSubtitle(): TemplateResult;
+    protected _renderDropzoneIcon(): TemplateResult;
+    protected _renderDefaultGlyph(): TemplateResult;
+    protected _renderRemoveIcon(): TemplateResult;
+    protected _renderThumbGlyph(item: FileUploadItem): TemplateResult;
+    /**
+     * An `i-mdi-*` class as inline SVG, or `undefined` when that glyph is not
+     * bundled (`scripts/mdi-glyphs.mjs` lists what is). The light build masks the
+     * class through the page's UnoCSS, which cannot cross the shadow boundary.
+     */
+    private _renderIconifyGlyph;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { LitElement, TemplateResult } from 'lit';
+import { MonoFilterController, MonoFilterSize } from './filter-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+import { CssSizeValue } from '../../composables/css-size';
+/** Per-build icon hooks the core delegates to. */
+export type FilterIconName = 'nested' | 'trash' | 'plus';
+/** Public surface added by the filter-builder core mixin. */
+export declare class MonoFilterBuilderCoreInterface extends LitElement {
+    dataFilter?: MonoFilterController;
+    size: MonoFilterSize;
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    protected renderIcon(name: FilterIconName): TemplateResult;
+    /** Pull `controlMonoFilterBuilder({ props })` onto this element. */
+    protected _applyControllerProps(): void;
+}
+/**
+ * `MonoFilterBuilderCore` — render-mode-agnostic logic for `mono-filter-builder`.
+ *
+ * Renders the controller's node tree as nested inline rows:
+ *
+ * ```
+ * Match [any ▾] of the following rules:
+ *   | field ▾ | operator ▾ | value | ⑃ | 🗑 |
+ * ```
+ *
+ * Per repo convention it renders **native** `<select>` / `<input>` carrying
+ * its OWN control classes — no component here embeds another `mono-*`
+ * element (`mono-table-search` set that precedent), so the controls match the rest
+ * of the library without a cross-element dependency.
+ */
+export declare const MonoFilterBuilderCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoFilterBuilderCoreInterface> & T;

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

@@ -0,0 +1,23 @@
+import { MonoFilterBuilderOptions, MonoFilterController } from './filter-types.js';
+/**
+ * `monoFilterBuilder` — headless controller behind `<mono-filter-builder>`.
+ *
+ * Owns the editable node tree and converts it to/from the two wire shapes. The
+ * element is pure presentation: it reads `tree` / `fields` / `texts` and calls the
+ * edit methods, then re-renders on `subscribe`.
+ *
+ * `filter` is **shape-flexible** — a devextreme array is normalised, an OData
+ * `$filter` string is parsed, decided by `typeof`, with no extra option. The output
+ * shape is chosen independently when reading (`original`/`changed` + `type`), so a
+ * string can go in and an array come out.
+ *
+ * @example
+ * const filter = monoFilterBuilder({
+ *   fields: [{ field: 'Name', caption: 'Name', dataType: 'string' }],
+ *   filter: "contains(Name,'Andy')",
+ * })
+ * filter.changed({ type: 'array' })   // [['Name','contains','Andy']]
+ */
+/** Renamed "control" alias of {@link monoFilterBuilder} (no breaking change — both work). */
+export { monoFilterBuilder as controlMonoFilterBuilder };
+export declare function monoFilterBuilder(opts?: MonoFilterBuilderOptions): MonoFilterController;

package/dist/src/components/filter/filter-odata.d.ts

@@ -0,0 +1,27 @@
+import { MonoFilterExpression, MonoFilterGroup, MonoFilterGroupOperator, MonoFilterNode } from './filter-types.js';
+export declare function nextId(prefix?: string): string;
+export declare function emptyGroup(operator?: MonoFilterGroupOperator): MonoFilterGroup;
+/** Split a comma-separated multi-value entry, trimming and dropping blanks. */
+export declare function splitMulti(value: unknown): unknown[];
+/** The node tree as a devextreme filter expression, or `null` when empty. */
+export declare function treeToArray(node: MonoFilterNode): MonoFilterExpression;
+/** Wrap a parsed node so the root is always a group the UI can add rules to. */
+export declare function asRootGroup(node: MonoFilterNode | null): MonoFilterGroup;
+/** devextreme expression → node tree. Returns `null` for an empty/unusable input. */
+export declare function arrayToTree(filter: unknown): MonoFilterNode | null;
+/**
+ * A devextreme filter expression → an OData `$filter` string. Nested groups get
+ * parentheses; `contains`/`startswith`/`endswith` become function calls.
+ */
+export declare function arrayToODataString(filter: unknown): string;
+/**
+ * Parse the subset of OData `$filter` the builder itself emits: parentheses,
+ * `and` / `or` / `not`, the six comparisons, `contains` / `startswith` /
+ * `endswith`, `in (…)`, `null`, and quoted / numeric / boolean literals.
+ *
+ * Anything outside that subset throws, and the caller (`monoFilterBuilder`) warns
+ * once and falls back to an empty tree — a wrong filter is worse than none.
+ */
+export declare function odataStringToArray(input: string): unknown[] | null;
+/** Flatten same-operator nesting so `[[a,'and',b],'and',c]` reads as one group. */
+export declare function flattenTree(node: MonoFilterNode): MonoFilterNode;

package/dist/src/components/filter/filter-operators.d.ts

@@ -0,0 +1,13 @@
+import { MonoFilterDataType, MonoFilterOperator, MonoFilterTexts } from './filter-types.js';
+/** How many value inputs an operator needs. */
+export type MonoFilterArity = 0 | 1 | 2 | 'many';
+/** Value inputs required per operator — drives the value cell. */
+export declare const OPERATOR_ARITY: Record<MonoFilterOperator, MonoFilterArity>;
+export declare function operatorsFor(dataType?: MonoFilterDataType): MonoFilterOperator[];
+/** The operator a field falls back to when its type has no current one. */
+export declare function defaultOperator(dataType?: MonoFilterDataType): MonoFilterOperator;
+/** English defaults for every label. `texts` overrides any of these. */
+export declare const DEFAULT_TEXTS: Required<MonoFilterTexts>;
+export declare function resolveTexts(texts?: MonoFilterTexts): Required<MonoFilterTexts>;
+/** Coerce a raw input string to the field's data type for the emitted filter. */
+export declare function coerceValue(raw: unknown, dataType?: MonoFilterDataType): unknown;