@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/datagrid/model/GridSummaries.d.ts

@@ -0,0 +1,91 @@
+import { type Bind } from '@motifx/core';
+import { data } from '@motifx-community/data';
+import type { GridSummary } from '../grid-summary';
+import type { GridSummaryValue } from '../grid-summary-value';
+import type { GridData } from './GridData';
+import type { GridModel } from './GridModel';
+import type { GroupNode } from './group-node';
+import type { PlacedItem } from './placed-item';
+import type { SummaryPart } from './summary-part';
+/**
+ * The grid's summaries: the items of the `summary` prop as they read now, their values and their
+ * texts. Totals of rows in memory are worked out at once; a source that loads pages or blocks asks
+ * its adapter (`remoteSummary`) or loads every matching row once per row set and works them out
+ * here. Group values come with a server's groups, or are worked out per group the first time a row
+ * shows it. Unsaved changes count while `recalculateWhileEditing` is on; saved ones always do.
+ */
+export declare class GridSummaries<T> {
+    private readonly model;
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        status: 'loading' | 'ready' | 'error';
+        version: number;
+    };
+    /** The grid, which `calculateCustomSummary` receives as `component`. */
+    component: unknown;
+    private readonly given;
+    private readonly totals;
+    /** Grows on `reread()`: the items are read again. */
+    private readonly look;
+    private data;
+    private subscriptions;
+    private generation;
+    private groupCache;
+    constructor(model: GridModel<T>, summary: Bind<GridSummary<T>> | undefined);
+    /** The `summary` prop as given (a value or a function). */
+    get value(): Bind<GridSummary<T>> | undefined;
+    set value(summary: Bind<GridSummary<T>> | undefined);
+    /** The summary as it reads now. Reactive. */
+    config(): GridSummary<T>;
+    /** How many times `reread()` was called: what works the values out reads them again when it grows. */
+    get rereads(): number;
+    /** The items and the rows are read again, and the values worked out again: something was changed in place. */
+    reread(): void;
+    /** The values of `totalItems`, in order. Reactive. */
+    get total(): readonly unknown[];
+    totalItems(): PlacedItem[];
+    groupItems(): PlacedItem[];
+    /** Whether the row of totals shows: an item is visible. Reactive. */
+    showsTotal(): boolean;
+    /** Whether each open group ends with a footer row. Reactive. */
+    /** Everything read of the summary as it is given, as text: what the grid follows of the functions in it. */
+    givenKey(): string;
+    hasFooters(): boolean;
+    /** What the values depend on (not how they show), as text: a change means working them out again. */
+    signature(): string;
+    /** The items as a server is asked for them, or `null` when the browser has to work them out. */
+    serverItems(items: readonly PlacedItem[], adapter: data.DataAdapter<T, unknown>): data.SummaryItem[] | null;
+    /** Follows the rows and the unsaved changes of new data. */
+    connect(gridData: GridData<T>): void;
+    /** Works the values out again; `editing` when only unsaved changes moved. */
+    refresh(editing?: boolean): void;
+    /** The values of `groupItems` for a group: a server's, or worked out from its rows once. Reactive. */
+    groupValues(node: GroupNode): readonly unknown[];
+    /** A total value by the item's name, place, type, column or `type_column`, as `getTotalSummaryValue`. Reactive. */
+    totalValue(name: string | number): unknown;
+    /** A group's value by the item's name (as `totalValue`). Reactive. */
+    groupValue(node: GroupNode, name: string | number): unknown;
+    /** The visible items of a group with their values and texts, in order; with `footer`, only those of the footer (or of the group row). Reactive. */
+    groupEntries(node: GroupNode, footer?: boolean): GridSummaryValue[];
+    /** The text of an item with its value; `''` when there is no value to show. */
+    text(i: PlacedItem, value: unknown, otherColumn: boolean): string;
+    /** An item ready to draw, or `null` when it has no value to show. */
+    part(i: PlacedItem, value: unknown, otherColumn: boolean): SummaryPart | null;
+    /** The parts of the visible items, by the column each shows under. Reactive. */
+    partsByColumn(items: readonly PlacedItem[], values: readonly unknown[]): Map<string, SummaryPart[]>;
+    dispose(): void;
+    private place;
+    private find;
+    private followsEdits;
+    private setTotal;
+    /** The values of `items` over `rows`; with `withNew`, unsaved new rows count too. */
+    private compute;
+    /** A `custom` item: `calculateCustomSummary` through start, a calculate per row, finalize. */
+    private custom;
+    private edits;
+    private pattern;
+    private title;
+    private format;
+}

package/dist/components/datagrid/model/GroupView.d.ts

@@ -0,0 +1,40 @@
+import type { GroupItemEntry } from './group-item-entry';
+import type { GroupNode } from './group-node';
+/**
+ * The grouped rows as one list, the way they show: each group's row, then, while it is expanded,
+ * its groups or its rows, and its footer row when there are `footers`. A collapsed group stands for
+ * all of its rows with its own row only. The list is kept as runs, so finding a place is a binary
+ * search however many rows there are.
+ */
+export declare class GroupView {
+    readonly roots: readonly GroupNode[];
+    readonly expanded: (node: GroupNode) => boolean;
+    readonly footers: boolean;
+    /** Places in the list. */
+    readonly size: number;
+    private readonly runs;
+    /** The runs of data rows, in data order. */
+    private readonly rowRuns;
+    private readonly placeOf;
+    private readonly footerPlaceOf;
+    constructor(roots: readonly GroupNode[], expanded: (node: GroupNode) => boolean, footers?: boolean);
+    /** Rows in every group. */
+    get rowCount(): number;
+    /** What sits at place `i`, or `null` past the end. */
+    itemAt(i: number): GroupItemEntry | null;
+    /** The place of a data row, or -1 while a collapsed group hides it. */
+    placeOfRow(d: number): number;
+    /** The place of a group's row, or -1 while a collapsed group above hides it. */
+    placeOfGroup(id: string): number;
+    /** The place of a group's footer, or -1 while it does not show. */
+    placeOfFooter(id: string): number;
+    /** The groups a data row is in, from the top level down. */
+    groupsOfRow(d: number): GroupNode[];
+    /** Where a data row shows: its own place, else the row of the collapsed group that hides it. */
+    shownPlaceOfRow(d: number): number;
+    /** The data rows shown at places `first` to `end - 1`, as runs `[from, to)`. */
+    rowsBetween(first: number, end: number): [number, number][];
+    /** Every group, in order, levels below included. */
+    allGroups(): GroupNode[];
+    private runAt;
+}

package/dist/components/datagrid/model/LayoutStore.d.ts

@@ -0,0 +1,16 @@
+import type { LayoutStorage } from '../layout-storage';
+import type { StoredLayout } from './stored-layout';
+/**
+ * A grid's layout, filters, search text and page size in `localStorage` (or the storage given) under its `layoutKey`.
+ * Storage can be missing, full or blocked (a private window, a sandbox): then nothing is kept and nothing fails.
+ */
+export declare class LayoutStore {
+    private readonly key;
+    private readonly storage?;
+    constructor(key: string, storage?: LayoutStorage | undefined);
+    private get place();
+    /** The kept layout, or `null` when there is none or it cannot be read. */
+    read(): StoredLayout | null;
+    write(layout: StoredLayout): void;
+    clear(): void;
+}

package/dist/components/datagrid/model/LiveOptions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Options of any name, kept as given (an array or an object comes back as it is). `view` reads and
+ * assigns them; a read is followed through one counter, which grows when a value is assigned.
+ */
+export declare class LiveOptions<T extends object> {
+    readonly view: T;
+    private readonly raw;
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    private readonly version;
+    constructor(given: object | undefined);
+    /** What reads the options reads them again: a value was changed in place. */
+    touch(): void;
+}

package/dist/components/datagrid/model/LookupTexts.d.ts

@@ -0,0 +1,72 @@
+import { type Event as MotifEvent } from '@motifx/core';
+import { data } from '@motifx-community/data';
+import { KeyedItems } from '../../../parts/data/KeyedItems';
+import type { TextSearch } from '../../../parts/data/text-search';
+import type { GridColumn } from '../grid-column';
+import type { EditorValue } from '../view/editor-value';
+import type { LookupCell } from './lookup-cell';
+/**
+ * The texts of the grid's lookup columns: a cell's key turned into the text of its item, through the
+ * shared cache of the column's source (`KeyedItems`). Cells ask for their keys when they are drawn;
+ * the keys of a moment go out together, and `onChanged` tells which ones came, so only those cells
+ * are drawn again. A text the user chose is remembered for its key (it shows at once, also over
+ * `textFrom` after the row is saved).
+ */
+export declare class LookupTexts<T> {
+    private readonly locale;
+    private readonly texts;
+    private readonly watched;
+    /** Texts the user chose, by column and key. */
+    private readonly chosen;
+    private readonly changedEmitter;
+    /** Keys of a cache were resolved (`keys`), or everything was cleared (`null`). */
+    readonly onChanged: MotifEvent<{
+        items: KeyedItems<any>;
+        keys: readonly string[] | null;
+    }>;
+    constructor(locale: () => string, texts: {
+        missing: () => string;
+    });
+    /** The cache of a lookup column's source now (the source may be a function that is followed). */
+    items(col: GridColumn<T>): KeyedItems<any> | null;
+    /** The text of an item: `textField`, else its `text`, else its value. */
+    textOf(col: GridColumn<T>, item: unknown): string;
+    /** How the column's items are searched by text; `entered` holds the values entered in the row. */
+    search(col: GridColumn<T>, row?: T | null, entered?: data.RowCheckContext<T>): TextSearch<any>;
+    /**
+     * What a lookup cell shows for `value`: a text the user chose, the row's own text (`textFrom`) while
+     * the value is the row's, the item's text, nothing while it loads (the key is asked for), or the key
+     * itself when the source does not have it.
+     */
+    cell(col: GridColumn<T>, row: T | undefined, value: unknown, edited: boolean, ask?: boolean): LookupCell;
+    /** What a key shows without a row (a group's key): a text the user chose, the item's text, nothing while it loads, or the key itself when the source does not have it. */
+    keyText(col: GridColumn<T>, value: unknown, ask?: boolean): LookupCell;
+    /** The text of a key as known now: the one the user chose, the item's, else the key itself. */
+    textOfKey(col: GridColumn<T>, value: unknown): string;
+    /** Remembers what the user chose for a key: its item (or its text), for this column and every list of the source. */
+    remember(col: GridColumn<T>, value: unknown, itemOrText: unknown): void;
+    /** Whether the source said it does not have the key (a failed request does not count). */
+    isMissing(col: GridColumn<T>, value: unknown): boolean;
+    /** Asks for the keys of the given rows in the lookup columns (as `valueOf` reads them: by default the unsaved edits left aside); resolves when all of them are known. */
+    load(cols: readonly GridColumn<T>[], rows: readonly T[], valueOf?: (row: T, col: GridColumn<T>) => unknown): Promise<void>;
+    /**
+     * A pasted or typed text read as a key: the one item whose text it is (case aside), among the items
+     * known, else asked from the source. None, or several, is a message.
+     */
+    parse(col: GridColumn<T>, text: string, row: T | null, entered: data.RowCheckContext<T>, messages: {
+        none: string;
+        several: string;
+    }): EditorValue | Promise<EditorValue>;
+    /**
+     * How rows in memory read this column for sorting: `sortField`, `textFrom`, the text shown
+     * (`lookup.sortBy: 'text'`), else `undefined` (the value).
+     */
+    sortValue(col: GridColumn<T>): ((row: T) => unknown) | undefined;
+    /** Rows in memory sort this lookup column by the text shown: every key of the rows must be known first. */
+    sortsByText(col: GridColumn<T>): boolean;
+    /** The field a server sorts by for this column: `sortField`, the field of `textFrom`, else the column's own. */
+    sortFieldOf(col: GridColumn<T>): string;
+    /** Forgets the texts of these columns; they are asked for again. */
+    refresh(cols: readonly GridColumn<T>[]): void;
+    dispose(): void;
+}

package/dist/components/datagrid/model/LookupValues.d.ts

@@ -0,0 +1,23 @@
+import { data } from '@motifx-community/data';
+import type { GridFilterValue } from '../grid-filter-value';
+import type { GridModel } from './GridModel';
+/**
+ * The lists of a lookup column's filter row ("(All)" first) and header filter ("(Blanks)" first),
+ * by text, searched by text. While `syncLookupFilterValues` is on they hold only the keys of the rows
+ * the other columns' filters leave: counted among rows in memory, asked from a server that groups,
+ * or from the app's `loadValues`; otherwise (or when the server cannot group) they list the lookup
+ * source itself. Keys become texts through the column's shared cache.
+ */
+export declare class LookupValues<T> {
+    private readonly model;
+    constructor(model: GridModel<T>);
+    /** The filter of the other columns (and the source's own), which a synced list honors. */
+    otherFilter(field: string): data.FilterExpression | null;
+    /** The list as a data source a `DropDown` or `ListBox` reads; `first` is the entry put before the values. */
+    source(field: string, first: 'all' | 'blank'): data.DataSource<GridFilterValue, unknown>;
+    private loader;
+    /** The keys among the rows the other filters leave; `null` when they cannot be had (a server that cannot group). */
+    private inRows;
+    /** The items of the lookup source itself, narrowed by `lookup.filter(null)`. */
+    private inSource;
+}

package/dist/components/datagrid/model/RowDragOptions.d.ts

@@ -0,0 +1,28 @@
+import type { GridRowDragging } from '../grid-row-dragging';
+import type { RowDraggingValues } from './row-dragging-values';
+import { Switches } from './Switches';
+/** The handlers of `rowDragging`: kept as they are, a function with no parameters too. */
+declare const HANDLERS: readonly ['onDragStart', 'onDragMove', 'onDragChange', 'onDragEnd', 'onReorder', 'onAdd', 'onRemove', 'dragTemplate'];
+type Handlers<T> = Pick<GridRowDragging<T>, (typeof HANDLERS)[number]>;
+/**
+ * The `rowDragging` options: the values (each a value or a function that is followed) and the
+ * handlers and `dragTemplate`, which are kept as they are. `view` reads and assigns both.
+ */
+export declare class RowDragOptions<T> {
+    readonly values: Switches<RowDraggingValues>;
+    readonly handlers: Handlers<T>;
+    readonly view: GridRowDragging<T>;
+    /** Called after a value is assigned through `view`. */
+    changed: ((key: string, value: unknown, previous: unknown) => void) | null;
+    /** Called when a value changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    constructor(given: GridRowDragging<T> | undefined);
+    get<K extends keyof RowDraggingValues>(key: K): RowDraggingValues[K];
+    /** A drag can start here: rows move within the grid, onto rows, or to the grids of a group. Reactive. */
+    get enabled(): boolean;
+    /** The drag icon column shows. Reactive. */
+    get showsIcons(): boolean;
+    /** Whether someone handles one of the events. */
+    listens(name: keyof Handlers<T>): boolean;
+}
+export {};

package/dist/components/datagrid/model/RowSelection.d.ts

@@ -0,0 +1,86 @@
+import { type Event as MotifEvent } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { GridSelection } from '../grid-selection';
+/**
+ * The selected rows, by row id (the key as text) with their keys. One by one, or "all": every row
+ * of the filter at that moment but the ones taken out, so selecting all never needs the rows. A
+ * Shift range starts from an anchor and adds to what was selected before it. Reads are reactive
+ * through `state.version`.
+ */
+export declare class RowSelection {
+    /** `run`: the grid rows a drag is selecting now (first and last), while it runs. */
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        version: number;
+        all: boolean;
+        run: {
+            top: number;
+            bottom: number;
+        } | null;
+    };
+    /** The change being made comes from rows selected by dragging over them. */
+    byDrag: boolean;
+    private keys;
+    private except;
+    private filter;
+    private anchorIndex;
+    private base;
+    private readonly changedEmitter;
+    /** Asked before a change shows (while `wanted()`): `false` puts the selection before back. */
+    guard: {
+        wanted: () => boolean;
+        allow: (next: GridSelection, previous: GridSelection) => boolean;
+    } | null;
+    /** The selection before the change being made, while the guard asks. */
+    private before;
+    readonly onChanged: MotifEvent<GridSelection>;
+    get all(): boolean;
+    /** Grid index the next Shift range starts from; -1 when there is none. */
+    get anchor(): number;
+    isSelected(id: string | undefined): boolean;
+    /** Rows selected out of `total` rows of the filter. */
+    count(total: number): number;
+    /** Whether nothing is selected. */
+    get empty(): boolean;
+    /** The number of rows taken out of "all", or picked one by one. */
+    get size(): number;
+    /** Selects a row or takes it out. Returns whether anything changed. */
+    set(id: string, key: unknown, on: boolean): boolean;
+    toggle(id: string, key: unknown): void;
+    /** Only this row; the anchor moves to it. */
+    only(id: string, key: unknown, index: number): void;
+    /** Starts a Shift range at grid row `index`, remembering what is selected now. */
+    setAnchor(index: number): void;
+    /** The selection from before the anchor, plus `rows` (the range from the anchor); `on` false takes them out of it. */
+    extend(rows: readonly [string, unknown][], on?: boolean): void;
+    /** Starts a run of rows from the anchor: added to the selection there is now (`keep`), or in place of it. */
+    startRun(keep: boolean): void;
+    /** The selection as it is now, to put back with `restore`. */
+    save(): {
+        all: boolean;
+        keys: Map<string, unknown>;
+        except: Map<string, unknown>;
+        filter: data.FilterExpression | null;
+        anchor: number;
+    };
+    /** Puts back a selection `save` kept (a drag given up). */
+    restore(saved: ReturnType<RowSelection['save']>): void;
+    /** Every row of `filter`. */
+    selectAll(filter: data.FilterExpression | null): void;
+    clear(): void;
+    /** Exactly these rows, one by one. */
+    replace(rows: readonly [string, unknown][]): void;
+    /** The filter changed: "all" was of the old rows, so it goes; rows picked one by one stay. */
+    filterChanged(): void;
+    /** Ids picked one by one (or taken out of "all"). */
+    ids(): string[];
+    snapshot(): GridSelection;
+    dispose(): void;
+    private put;
+    /** Keeps the selection as it is now, so a change the guard refuses can be taken back. */
+    private remember;
+    /** The change is made: the guard is asked first, then it shows and is told. Returns whether it stays. */
+    private changed;
+}

package/dist/components/datagrid/model/ScrollGeometry.d.ts

@@ -0,0 +1,84 @@
+import type { ExtraHeights } from './ExtraHeights';
+/**
+ * Scroll geometry of the virtual body. Browsers cap the height of an element (Firefox at about 17.9
+ * million pixels), so when the rows would be taller than `max` the spacer stays at that height and the
+ * scroll bar position is mapped proportionally to a "virtual" offset in the full content. Rows are then
+ * placed relative to the scroll position, so the wheel and the keyboard still move row by row.
+ */
+export declare class ScrollGeometry {
+    /** Row count. */
+    readonly total: number;
+    readonly rowHeight: number;
+    /** Visible height of the body (the viewport minus the sticky header). */
+    readonly viewport: number;
+    readonly max: number;
+    /** One row taller than the others (the edit form in place of a row): its position and the height it adds. */
+    readonly tall: {
+        at: number;
+        extra: number;
+    } | null;
+    /** Heights added under rows (their open details), by position. */
+    readonly details: ExtraHeights | null;
+    /** The row with its adaptive detail open, right under it (before its details): its position and the detail's height. */
+    readonly adaptive: {
+        at: number;
+        height: number;
+    } | null;
+    /** Room after the last row (the loading indicator of infinite mode). */
+    readonly tail: number;
+    /** Spacer height above which scrolling is scaled; well under every browser's limit. */
+    static readonly MAX_HEIGHT = 10000000;
+    constructor(
+    /** Row count. */
+    total: number, rowHeight: number, 
+    /** Visible height of the body (the viewport minus the sticky header). */
+    viewport: number, max?: number, 
+    /** One row taller than the others (the edit form in place of a row): its position and the height it adds. */
+    tall?: {
+        at: number;
+        extra: number;
+    } | null, 
+    /** Heights added under rows (their open details), by position. */
+    details?: ExtraHeights | null, 
+    /** The row with its adaptive detail open, right under it (before its details): its position and the detail's height. */
+    adaptive?: {
+        at: number;
+        height: number;
+    } | null, 
+    /** Room after the last row (the loading indicator of infinite mode). */
+    tail?: number);
+    /** Height of all rows, and the room after them. */
+    get contentHeight(): number;
+    /** Top of row `index` in the full content. */
+    offsetOf(index: number): number;
+    /** Height of row `index` itself (the edit form when it stands for the row), without its details. */
+    rowHeightOf(index: number): number;
+    /** Height of the adaptive detail under row `index` (0 when it has none open). */
+    adaptiveAt(index: number): number;
+    /** Height of row `index` with its adaptive detail and its details under it. */
+    heightOf(index: number): number;
+    /** The row at an offset in the full content (a row's details count as the row). */
+    indexAt(offset: number): number;
+    /** The last row that starts at or before `offset`, by halving. */
+    private search;
+    private adaptiveBefore;
+    private get extraHeight();
+    /** Height given to the spacer element. */
+    get spacerHeight(): number;
+    get scaled(): boolean;
+    /** Largest valid virtual offset. */
+    get maxVirtualTop(): number;
+    /** Virtual offset (position in the full content) of the viewport top for a native `scrollTop`. */
+    virtualFromScroll(scrollTop: number): number;
+    /** Native `scrollTop` that shows the given virtual offset. */
+    scrollFromVirtual(virtualTop: number): number;
+    /** Top of row `index` inside the spacer, for the current native and virtual offsets. */
+    rowTop(index: number, scrollTop: number, virtualTop: number): number;
+    /** Rows that intersect the viewport: `first` inclusive, `end` exclusive. */
+    visibleRange(virtualTop: number): {
+        first: number;
+        end: number;
+    };
+    /** Virtual offset that brings row `index` fully into view (its details need not be): `nearest` moves as little as possible, `start` / `end` align it. */
+    revealRow(virtualTop: number, index: number, align?: 'nearest' | 'start' | 'end'): number;
+}

package/dist/components/datagrid/model/Switches.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Named values that are each a plain value or a function that is followed (a function without
+ * parameters is a getter; one with parameters is kept as the value). `get` reads one, tracked, and
+ * falls back to the defaults; `view` is an object whose fields read and assign them, so
+ * `grid.settings.striped = () => state.zebra` binds and `grid.settings.striped = true` sets.
+ *
+ * The values are kept as given (an array or an object comes back as it is); a value is followed
+ * through its own counter, which grows when a new value is assigned.
+ */
+export declare class Switches<T extends object> {
+    private readonly keys;
+    private readonly defaults;
+    readonly view: T;
+    /** Called after a value is assigned through `view`, with the value read before and after. */
+    changed: ((key: keyof T & string, value: unknown, previous: unknown) => void) | null;
+    /** Called when a value changed or was touched (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private readonly raw;
+    private readonly versions;
+    constructor(keys: readonly (keyof T & string)[], defaults?: Partial<T>, given?: object);
+    /** The value, or the default while none is set. */
+    get<K extends keyof T & string>(key: K): T[K];
+    /** The value set for this key, without the default. */
+    own<K extends keyof T & string>(key: K): T[K] | undefined;
+    /** What reads `key` reads it again: its value was changed in place. */
+    touch(key: keyof T & string): void;
+    /** What reads any value reads it again. */
+    touchAll(): void;
+    /**
+     * The keys given as functions (a getter, `() => state.width`) with what they return now: whoever calls this follows
+     * what they read. A value assigned later is told (`notify`), not followed.
+     */
+    givenValues(): Map<string, unknown>;
+    /** Touches the keys whose given function returns another value than before. */
+    touchChanged(before: ReadonlyMap<string, unknown>, now: ReadonlyMap<string, unknown>): void;
+}

package/dist/components/datagrid/model/ValueIntervals.d.ts

@@ -0,0 +1,27 @@
+import { data } from '@motifx-community/data';
+import type { ColumnType } from '../column-type';
+import type { GridDateInterval } from '../grid-date-interval';
+import type { GridHeaderFilterInterval } from '../grid-header-filter-interval';
+/**
+ * The levels a header filter groups a column's values by: date parts (year → month → day …, or
+ * year → quarter) or ranges of numbers, the largest first. A node is kept in the column's filter as
+ * its path: the first part alone as a number (`2024`, `100`), deeper ones joined by `/` (`'2024/3'`,
+ * `'1000/1200'`), so a value tells its own level, and stands for a range (`>=` its start, `<` its end).
+ */
+export declare class ValueIntervals {
+    readonly kind: 'number' | 'date';
+    readonly levels: readonly (number | GridDateInterval)[];
+    private constructor();
+    /** The levels of a column, from its own interval or (dates) the grid's; `null` for one entry per value. */
+    static of(type: ColumnType | undefined, own: GridHeaderFilterInterval | undefined, dateDefault: GridDateInterval | null): ValueIntervals | null;
+    /** More than one level: the values show as a tree. */
+    get isTree(): boolean;
+    /** The parts of a value, one per level (`[2024, 3, 15]`, `[1000, 1200]`); `null` for an empty or unreadable one. */
+    partsOf(value: unknown): number[] | null;
+    /** What the filter keeps for the node of the first `depth` parts. */
+    keyOf(parts: readonly number[], depth: number): number | string;
+    /** The parts a kept value names; `null` when it names none. */
+    partsOfKey(key: unknown): number[] | null;
+    /** The rows a kept value stands for: from its start up to (not with) its end; `null` when it names none. */
+    condition(field: string, key: unknown): data.FilterExpression | null;
+}

package/dist/components/datagrid/model/ValueListAdapter.d.ts

@@ -0,0 +1,17 @@
+import { data } from '@motifx-community/data';
+import type { GridFilterValue } from '../grid-filter-value';
+import type { ValueLoader } from './value-loader';
+/**
+ * The values of a header filter as a data-layer adapter, so the kit's `ListBox` lists, searches and
+ * scrolls them like any other data: a search arrives as a filter on `text` and goes to the loader,
+ * a value asked by key is answered from what was loaded.
+ */
+export declare class ValueListAdapter extends data.DataAdapter<GridFilterValue, unknown> {
+    private readonly loader;
+    private readonly textOf;
+    private readonly known;
+    constructor(loader: ValueLoader, textOf: (value: unknown) => string | Promise<string>);
+    protected backendCapabilities(): data.Capabilities;
+    protected loadRows(options: data.LoadOptions): Promise<data.LoadResult<GridFilterValue>>;
+    protected findRow(key: unknown): Promise<GridFilterValue | undefined>;
+}

package/dist/components/datagrid/model/action-entry.d.ts

@@ -0,0 +1,22 @@
+import type { GridAction } from '../grid-action';
+import type { GridSelection } from '../grid-selection';
+import type { RowState } from '../row-state';
+/** An action the target rows share: shown once, run on each of its rows with that row's own action. */
+export interface ActionEntry<T> {
+    /** The first row's action: its text, icon and look. */
+    action: GridAction<T>;
+    text: string;
+    /** Rows it runs on. */
+    count: number;
+    disabled: boolean;
+    /** The rows it runs on, each with its state and its own action. */
+    items: {
+        row: T;
+        state: RowState;
+        action: GridAction<T>;
+    }[];
+    /** The selection it runs on when the rows are not loaded; else `null`. */
+    selection: GridSelection | null;
+    /** The rows came from the selection. */
+    fromSelection: boolean;
+}

package/dist/components/datagrid/model/action-target.d.ts

@@ -0,0 +1,16 @@
+import type { GridSelection } from '../grid-selection';
+/**
+ * What the bars' actions act on: nothing, loaded rows (the selected ones or the active one), or a
+ * selection whose rows are not all loaded ("select all" over a server), kept as a state.
+ */
+export type ActionTarget<T> = {
+    kind: 'none';
+} | {
+    kind: 'rows';
+    rows: T[];
+    from: 'selection' | 'focused';
+} | {
+    kind: 'selection';
+    selection: GridSelection;
+    count: number;
+};

package/dist/components/datagrid/model/adaptive-detail-values.d.ts

@@ -0,0 +1,11 @@
+import type { FieldLabelMode } from '../../../parts/field/field-label-mode';
+/** The `adaptiveDetail` options as the grid reads them: values, not functions. */
+export interface AdaptiveDetailValues {
+    colCount: number;
+    minColWidth: string | undefined;
+    labelMode: FieldLabelMode;
+    editors: boolean;
+    expandOnEdit: boolean;
+    columnWidth: number;
+    toggleKeys: readonly string[];
+}

package/dist/components/datagrid/model/added-row.d.ts

@@ -0,0 +1,6 @@
+/** A row in the new-row area: added in the grid; it stays there after it is saved, until a refresh. */
+export interface AddedRow<T> {
+    /** The tracker's id of the row (`+1`, `+2` …). */
+    rowId: string;
+    row: T;
+}

package/dist/components/datagrid/model/adjustment.d.ts

@@ -0,0 +1,10 @@
+/** A keyboard move or resize of a column, started from the column menu. */
+export interface Adjustment {
+    kind: 'move' | 'resize';
+    field: string;
+    /** Order (move) or widths and flex shares (resize) before it started, for Escape. */
+    original: string[] | {
+        width: Record<string, number>;
+        flex: Record<string, number>;
+    };
+}

package/dist/components/datagrid/model/band-node.d.ts

@@ -0,0 +1,8 @@
+import type { GridBand } from '../grid-band';
+/** A band as the column model keeps it. */
+export interface BandNode<T> {
+    readonly id: string;
+    readonly def: GridBand<T>;
+    /** Its columns and bands, by field and id, in the order given. */
+    readonly children: string[];
+}

package/dist/components/datagrid/model/builder-fields.d.ts

@@ -0,0 +1,10 @@
+import type { FilterBuilderCustomOperation } from '../../filterbuilder/filter-builder-custom-operation';
+import type { FilterBuilderField } from '../../filterbuilder/filter-builder-field';
+import type { GridModel } from './GridModel';
+/**
+ * The filter builder's fields of a grid: every column with `filterBuilder` on, hidden ones too, by
+ * its type, a list or lookup column as a lookup, its values written as its cells write them. The
+ * operations are the column's `filterOperators`, else those of its type with "is any of" and "is
+ * none of" (the header filter's) and the custom operations for its type.
+ */
+export declare function builderFields<T>(model: GridModel<T>, customOperations?: readonly FilterBuilderCustomOperation[]): FilterBuilderField[];