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

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

@@ -0,0 +1,88 @@
+import { type Event as MotifEvent } from '@motifx/core';
+import type { GridCellRange } from '../grid-cell-range';
+import type { CellCorner } from './cell-corner';
+import type { CellRangeEntry } from './cell-range-entry';
+import type { GridModel } from './GridModel';
+import type { RangeBox } from './range-box';
+import type { RangeLook } from './range-look';
+/**
+ * The cell ranges drawn by the user (or set by code), as in a spreadsheet: each one from the cell it
+ * was started on to its far corner, over the columns between them. Corners keep their row by id and
+ * key, so a range follows its rows when rows are added above them or loaded again; the columns are
+ * kept by field, so a range keeps its columns when they move. Reads are reactive through
+ * `state.version`. The last range is the one a Shift extension and the keys change.
+ */
+export declare class CellRanges<T> {
+    private readonly model;
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        version: number;
+    };
+    /** The change being made comes from a range drawn with the pointer. */
+    byDrag: boolean;
+    /** Asked before a change shows (while `wanted()`): `false` keeps the ranges as they were. */
+    guard: {
+        wanted: () => boolean;
+        allow: (next: GridCellRange[], previous: GridCellRange[]) => boolean;
+    } | null;
+    private list;
+    private found;
+    private readonly changedEmitter;
+    /** The rows' look, worked out once per change and read by every row. */
+    private readonly lookOf;
+    readonly onChanged: MotifEvent<GridCellRange[]>;
+    constructor(model: GridModel<T>);
+    /** What the rows draw of the ranges and of a drag's run. Reactive. */
+    get look(): RangeLook;
+    get entries(): readonly CellRangeEntry[];
+    get empty(): boolean;
+    get last(): CellRangeEntry | undefined;
+    /** The columns cells can be selected in: the visible data columns that allow it, in display order. Reactive. */
+    axis(): string[];
+    /** A corner at grid row `index`, column `field`. */
+    corner(index: number, field: string): CellCorner;
+    /** The grid index of a corner's row now: found by id or key, else where it was. */
+    find(corner: CellCorner): number;
+    /** The columns from `a` to `b` along the axis (both included); the two alone when one is not on it. */
+    between(a: string, b: string, axis?: string[]): string[];
+    /** The ranges in the rows shown now, cut to their first and last data rows; ranges with no data row left out. Reactive. */
+    boxes(): RangeBox[];
+    /**
+     * What grid row `index` shows of the ranges, by field: `''` for a cell inside one, else its edges
+     * (`top`, `bottom`, `start`, `end`) and `anchor` for the cell the last range started on. `null`
+     * while the row is in none.
+     */
+    marksOf(index: number, look: RangeLook): Map<string, string> | null;
+    /** Calls `fn` for each row with selected cells, in grid order, with its selected columns in display order. */
+    forEachRow(fn: (index: number, fields: string[]) => void): void;
+    /** The selected cells, each once. */
+    count(): number;
+    /** The last range's size: its data rows and its columns on the axis. */
+    size(): {
+        rows: number;
+        columns: number;
+    };
+    /** Starts a range at `anchor`, alone or (`add`) after the others. Returns whether it shows. */
+    begin(anchor: CellCorner, add: boolean): boolean;
+    /** The last range's far corner moves to `extent`, its columns with it. Returns whether that changed anything. */
+    extendTo(extent: CellCorner): boolean;
+    /** Exactly these ranges. Returns whether they show. */
+    set(list: readonly CellRangeEntry[]): boolean;
+    /** Takes the last range out (one being drawn when the drag is given up). */
+    dropLast(): boolean;
+    clear(): boolean;
+    /** The rows changed under the ranges (another sort, filter, grouping, page, data): they go, without asking. */
+    reset(): void;
+    /** The ranges as the API gives them. */
+    toPublic(list?: readonly CellRangeEntry[]): GridCellRange[];
+    /** A range of the API as the grid keeps it; `null` when a corner names no row or column of the grid. */
+    fromPublic(range: GridCellRange): CellRangeEntry | null;
+    dispose(): void;
+    private findLook;
+    private point;
+    private cornerOf;
+    private apply;
+    private changed;
+}

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

@@ -0,0 +1,34 @@
+import { data } from '@motifx-community/data';
+import type { UiStrings } from '../../../core/ui-strings';
+import type { GridColumn } from '../grid-column';
+/**
+ * The columns' `validationRules`, checked with the kit's `checkRules`. A result is kept per row and
+ * field with the value it was found for: the same value is not checked again, except by a rule that
+ * asks for it (`reevaluate`, `compare`), which runs once per check of the row (`round`).
+ */
+export declare class CellRules<T> {
+    private readonly text;
+    /** Grows with each check of a row the user or the code starts. */
+    round: number;
+    private readonly results;
+    /** Checks still running, so the same value is not checked twice at once. */
+    private readonly running;
+    constructor(text: (key: keyof UiStrings) => string);
+    has(col: GridColumn<T>): boolean;
+    /** A rule waits for a promise: the cell shows that it is busy meanwhile. */
+    waits(col: GridColumn<T>): boolean;
+    /** A column that must be filled in: a `required` rule. */
+    requires(col: GridColumn<T>): boolean;
+    /** The message found for this value (`''`: it passed), or `undefined` when it has to be checked. */
+    known(rowId: string, col: GridColumn<T>, value: unknown): string | undefined;
+    /** Checks the value against the column's rules: the ones in order, then the `async` ones together. A check of the same value still running is shared. */
+    check(rowId: string, col: GridColumn<T>, value: unknown, row: T, context: data.RowCheckContext<T>): Promise<string>;
+    /** Drops what was found for a row, or for every row. */
+    forget(rowId?: string): void;
+    private keep;
+    private checkNow;
+    private one;
+    /** The rule's own message, else the grid's text (its `texts`, then `uiLocale`). */
+    private message;
+    private run;
+}

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

@@ -0,0 +1,251 @@
+import type { BandLayout } from '../band-layout';
+import type { ColumnFeatures } from '../column-features';
+import type { ColumnLayout } from '../column-layout';
+import type { ColumnResizeMode } from '../column-resize-mode';
+import type { GridColumn } from '../grid-column';
+import type { GridColumnItem } from '../grid-column-item';
+import type { GridLayout } from '../grid-layout';
+import type { GridSettings } from '../grid-settings';
+import type { StickySide } from '../sticky-side';
+import type { BandNode } from './band-node';
+import type { ColumnZone } from './column-zone';
+import type { StickyOffset } from './sticky-offset';
+import { Switches } from './Switches';
+/**
+ * Field of the row status column: added by the grid, always first, not part of the layout, and shown
+ * only while rows can be edited or added (`showsStatus`).
+ */
+export declare const STATUS_FIELD = "mx:status";
+/** Field of the check box column of multiple selection: after the status column, pinned to the start. */
+export declare const SELECT_FIELD = "mx:select";
+/** Field of the actions column: at the start or the end, pinned or scrolling, by the settings. */
+export declare const ACTIONS_FIELD = "mx:actions";
+/** Field of the expand column of `masterDetail`: after the status and check box columns, pinned to the start. */
+export declare const EXPAND_FIELD = "mx:expand";
+/** Field of the "…" column that opens a row's adaptive detail: last of the scrolling columns, while columns hide to fit the width. */
+export declare const ADAPTIVE_FIELD = "mx:adaptive";
+/** Field of the drag icon column of `rowDragging`: after the status column, pinned to the start. */
+export declare const DRAG_FIELD = "mx:drag";
+/**
+ * Column layout state: order, widths, visibility and sticky sides, and what the user may change per
+ * column. Reactive, so views that read `visible()`, `width()` or `can()` inside getters follow every
+ * change. Display order is always start-sticky columns, then the free ones, then end-sticky ones,
+ * each group in `order`. Bands (`GridBand`) sit over their columns: a band's columns stay together
+ * in `order`, pinned, hidden and moved with it; they move only among themselves. Columns the width
+ * hides (`columnHidingEnabled`) are left out of `visible()` and still count as shown everywhere else.
+ */
+export declare class ColumnModel<T> {
+    private readonly settings;
+    readonly defs: Map<string, GridColumn<T>>;
+    /** The bands by id. */
+    readonly bands: Map<string, BandNode<T>>;
+    /** Each column's and band's own feature switches; a value left unset follows the grid's settings. */
+    readonly features: Map<string, Switches<ColumnFeatures>>;
+    /** Called when the state above changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    readonly state: {
+        order: string[];
+        width: Record<string, number>;
+        flex: Record<string, number>;
+        hidden: Record<string, boolean>;
+        sticky: Record<string, StickySide | null>;
+        adaptive: string[];
+        revision: number;
+    };
+    /** The fields in the order the columns were given (and added), for `reset`. */
+    private readonly given;
+    /** The band each column and band sits in, or `null` at the top. */
+    private readonly owners;
+    /** What the last layout applied said of columns the grid did not have; a column added later takes it. */
+    private readonly waiting;
+    /** Whether something besides editing needs the status column (unsaved changes made in code). */
+    statusWanted: () => boolean;
+    /** Whether the grid has row actions to show. */
+    actionsWanted: () => boolean;
+    /** Whether some action sits in the row (not in a bar). */
+    actionsInRow: () => boolean;
+    /** The width of the actions column in the `'menu'` display (the "more" button alone), or `null`. */
+    actionsMenuWidth: () => number | null;
+    /** Whether a column is out of the columns because the rows are grouped by it. */
+    hiddenByGroup: (field: string) => boolean;
+    /** Whether the expand column of `masterDetail` shows. */
+    expandWanted: () => boolean;
+    /** The width of the expand column. */
+    expandWidth: () => number;
+    /** The width of the "…" column. */
+    adaptiveWidth: () => number;
+    /** Whether the drag icon column of `rowDragging` shows. */
+    dragWanted: () => boolean;
+    /** The width of the drag icon column. */
+    dragWidth: () => number;
+    constructor(columns: readonly GridColumnItem<T>[], layout?: GridLayout, settings?: Switches<GridSettings>);
+    /** The data columns' definitions, in the order they were given and added. */
+    definitions(): GridColumn<T>[];
+    /**
+     * Adds a column (or a band with its columns) at `index` among the data columns (default: last),
+     * with its own width, visibility and sticky side, or what the last layout applied said of it. A
+     * column with `ownerBand` goes into that band.
+     */
+    add(column: GridColumnItem<T>, index?: number): void;
+    /** Takes a data column out, with its layout; its band keeps its other columns. */
+    remove(field: string): void;
+    /** Another definition for a column; its layout and feature switches stay. */
+    replace(column: GridColumn<T>): void;
+    /** Columns the grid adds itself: row status, selection, expand, actions, the "…" column. */
+    isInternal(field: string): boolean;
+    /** The definition of a column. */
+    get(field: string): GridColumn<T>;
+    isBand(id: string): boolean;
+    /** Whether the columns have bands over them. */
+    get hasBands(): boolean;
+    /** The header text of a column or a band; nothing for a column that went (what showed it may still be going). */
+    title(field: string): string;
+    /** Alignment of the column's cells: its own, else by type. */
+    align(field: string): 'start' | 'center' | 'end';
+    /** Where a band's caption sits: its own, else the `bandAlign` setting. */
+    bandAlign(id: string): 'start' | 'center' | 'end';
+    /** Whether the user may use `feature` on this column or band: its own value, else the grid's. */
+    can(field: string, feature: keyof ColumnFeatures): boolean;
+    /**
+     * Whether the search panel looks in a column: its own `searchable`, else off when the column turns
+     * its own filters off, else the grid's `searchable`.
+     */
+    canSearch(field: string): boolean;
+    /** Whether `feature` is on for at least one visible column. */
+    canAny(feature: keyof ColumnFeatures): boolean;
+    /** Whether a cell can be edited in `row`: the column's own value or row function, else the grid's setting (columns with a `value` reader only when they say so). */
+    canEdit(field: string, row: T): boolean;
+    /** Whether a cell can be filled in a new row: the column's `creatable`, else its own `editable`, else the grid's `creatable`. */
+    canCreate(field: string, row: T): boolean;
+    /** `canCreate` for a new row (never saved yet), `canEdit` for any other. */
+    canFill(field: string, row: T, isNew: boolean): boolean;
+    /** Whether the column is editable in some rows. */
+    isEditable(field: string): boolean;
+    /** The status column shows while rows can be edited or added, or while there are unsaved changes. */
+    showsStatus(): boolean;
+    /** The check box column shows in multiple selection, while its setting is on. */
+    showsSelect(): boolean;
+    showsActions(): boolean;
+    /** The edge a column or band sticks to, or `null`: a band's columns stick with the band at the top. The grid's own columns take theirs from the settings. */
+    sideOf(field: string): StickySide | null;
+    /** Visible data columns on the screen (no internal ones, none the width hides), in display order. */
+    visibleData(): string[];
+    /** Data columns the user has shown, those the width hides too, in display order. */
+    listedData(): string[];
+    /** Back to the columns' own settings. */
+    reset(): void;
+    zoneOf(field: string): ColumnZone;
+    /** Visible fields in display order: status, check boxes, expand, then the zones; the actions column first or last in its zone, the "…" column last of the scrolling ones. */
+    visible(): string[];
+    /** Visible fields of one zone, in display order. */
+    zone(zone: ColumnZone): string[];
+    /** The band a column or band sits in, or `null` at the top. */
+    bandOf(id: string): string | null;
+    /** The band at the top over a column or band, or the column itself. */
+    topOf(id: string): string;
+    /** How deep a band sits: 1 at the top. */
+    depthOf(id: string): number;
+    /** Whether `field` sits under band `id` (at any depth). */
+    isUnder(field: string, id: string): boolean;
+    /** The visible columns under a band, from a list of visible fields. */
+    leavesIn(id: string, visible: readonly string[]): string[];
+    /** The bands that show over `visible`, with the columns under each: a band shows while one of its columns does. */
+    shownBands(visible: readonly string[]): {
+        id: string;
+        depth: number;
+        first: number;
+        count: number;
+    }[];
+    /** Header rows above the columns' own: as many as the deepest band shown. Reactive. */
+    bandDepth(): number;
+    /** Whether a band or one above it was hidden itself (not by hiding its columns). */
+    inHiddenBand(id: string): boolean;
+    /** Whether a band shows: not hidden, and one of its columns shows. */
+    bandShown(id: string): boolean;
+    width(field: string): number;
+    /** The smallest width of a column: its own `minWidth`, else the `columnMinWidth` setting. */
+    minWidth(field: string): number;
+    clampWidth(field: string, px: number): number;
+    /** `grid-template-columns` for the given visible fields. Sticky columns never flex. */
+    template(visible: string[]): string;
+    /** Offsets of the sticky columns from their edge. */
+    stickyOffsets(visible: string[]): Map<string, StickyOffset>;
+    /** Width taken by the sticky columns at each edge. */
+    stickyWidths(visible: string[]): {
+        start: number;
+        end: number;
+    };
+    /** Sets a width (clamped). Resizing turns flex off for that column. Returns the width set. */
+    resize(field: string, px: number): number;
+    /** How the column's edge is dragged: its own mode, else the grid's. */
+    resizeModeOf(field: string): ColumnResizeMode;
+    /** Whether a column gets cells only while it is in view: its own `columnRenderingMode`, else the grid's. The grid's own columns always have theirs. Reactive. */
+    isVirtual(field: string): boolean;
+    /** Whether some visible column is virtual. Reactive. */
+    anyVirtual(visible: readonly string[]): boolean;
+    /**
+     * The column that gives or takes the width when `field` is resized in `'nextColumn'` mode: the
+     * next visible one in its zone, if it can be resized. Without one the column changes alone.
+     */
+    partnerOf(field: string): string | undefined;
+    /**
+     * Moves the edge between a column and the next one: `field` gets `px`, `next` gets the rest of
+     * `total`, both within their limits. Turns flex off for both. Returns the width of `field`.
+     */
+    resizeWithNext(field: string, next: string, total: number, px: number): number;
+    /**
+     * What a column or band moves among: the columns and bands shown beside it in its band (or at
+     * the top) and its zone, in display order. A band counts once, for all its columns.
+     */
+    siblings(id: string): string[];
+    /** The data columns and bands shown beside a column or band in its band (or at the top), in every zone. */
+    shownBeside(id: string): string[];
+    /** The data columns and bands in a band (or at the top), in their order, the hidden ones too. */
+    childrenOf(parent: string | null): string[];
+    /**
+     * Places a column or band can reach among its `siblings`: up to, not across, the nearest that
+     * cannot move (they keep their place). `[from, from]` when it cannot move itself.
+     */
+    moveRange(id: string): [number, number];
+    /** Moves a column or band to `index` among its `siblings`, within `moveRange`; a band takes all its columns. Hidden columns keep their place. */
+    move(id: string, index: number): boolean;
+    /** Moves by `delta` places among its `siblings`. */
+    moveBy(id: string, delta: number): boolean;
+    /** Hides or shows a column or band. The last visible data column cannot be hidden. */
+    setHidden(id: string, hidden: boolean): boolean;
+    /** Pins a column or band, or unpins it; a column in a band pins its band at the top. */
+    setSticky(id: string, side: StickySide | null): boolean;
+    toLayout(): ColumnLayout[];
+    /** The bands' own hidden and sticky state, for the layout. */
+    bandLayout(): BandLayout[];
+    /** Applies a saved layout. Unknown fields are ignored; columns missing from it keep their settings and go last. A band's columns stay together. */
+    applyLayout(layout: GridLayout): void;
+    /**
+     * The columns the width hides: while the visible columns are wider than `width`, the lowest
+     * `hidingPriority` first (given on any column, only columns with one hide), else, with
+     * `columnHidingEnabled`, the last one first; the "…" column takes its place. Pinned and grouped
+     * columns stay, and so does one data column. Reads the widths kept, never the screen, so hiding
+     * cannot feed back into it.
+     */
+    fitWidth(width: number): string[];
+    /** Visible fields in display order; `adaptive` leaves out the columns the width hides and adds the "…" column. */
+    private arranged;
+    /** The child of `parent` (a band, or `null` for the top) that holds `field`, or `undefined` when it is not under it. */
+    childOf(field: string, parent: string | null): string | undefined;
+    /** Every band's columns together, where its first one is; inside a band, in the order they come. */
+    private together;
+    /** Takes columns and bands into the model, under `owner`; flat ones with `ownerBand` go under that band. */
+    private take;
+    /** How many columns and bands sit at the top already, so a band added later gets a name of its own. */
+    private topCount;
+    /** Puts a column or band under `parent` (taking it from where it was). */
+    private adopt;
+    private tell;
+    /** A column's (or band's) own feature switches; a change to them is a change of the columns. */
+    private makeFeatures;
+    /** At least one data column stays shown. */
+    private keepOneShown;
+    private check;
+    /** The column's own `editable` or `creatable`: a value, a function of the row, or unset. */
+    private ownRule;
+}

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

@@ -0,0 +1,32 @@
+import type { GridSettings } from '../grid-settings';
+import type { ColumnModel } from './ColumnModel';
+import type { Switches } from './Switches';
+/**
+ * The columns that get cells while some columns are virtual (`columnRenderingMode: 'virtual'`): the
+ * pinned ones, the scrolling ones in view with `extraColumns` more on each side, the ones kept (the
+ * active column, the one in edit) and every column that is not virtual. Worked out from the widths
+ * the columns are given, not from the DOM, so a column without cells still has its place.
+ */
+export declare class ColumnWindow<T> {
+    private readonly columns;
+    private readonly settings;
+    /** Every column gets cells for now (fitting them all to their content). */
+    everything: boolean;
+    /** The fields that get cells; `null` while every column does. */
+    private drawn;
+    constructor(columns: ColumnModel<T>, settings: Switches<GridSettings>);
+    /** No column is left without cells now. */
+    get all(): boolean;
+    /** Whether a column gets cells now. */
+    has(field: string): boolean;
+    /** How many columns get cells now, out of `visible`. */
+    count(visible: readonly string[]): number;
+    /**
+     * Works the columns out again for rows scrolled `start` pixels sideways (from the inline start) in
+     * a viewport `width` pixels wide; `true` when other columns get cells now.
+     */
+    update(visible: readonly string[], start: number, width: number, keep: readonly string[]): boolean;
+    /** Where a column starts from the inline start of the row, by the widths given. */
+    offsetOf(field: string, visible: readonly string[]): number;
+    private find;
+}

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

@@ -0,0 +1,42 @@
+import type { GridMasterDetail } from '../grid-master-detail';
+import type { MasterDetailValues } from './master-detail-values';
+import { Switches } from './Switches';
+/**
+ * Which rows have their details open, by key: either every row but some (`autoExpandAll`,
+ * `expandAllRows()`) or no row but some. Keys are kept as text (the data's `keyString`), so the
+ * state holds across sort, filter, search, grouping and pages; the raw keys are kept to find the rows.
+ */
+export declare class DetailRows<T> {
+    readonly options: Switches<MasterDetailValues<T>>;
+    /** Raised when rows open or close. Reactive. */
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        version: number;
+    };
+    private all;
+    /** Rows that differ from `all`: key text → key. */
+    private readonly toggled;
+    constructor(given: GridMasterDetail<T> | undefined);
+    /** Rows can have details: a template is given. Reactive. */
+    get on(): boolean;
+    /** The user opens and closes them (the expand column shows). Reactive. */
+    get enabled(): boolean;
+    /** Every row is open but `exceptions()`. */
+    get allOpen(): boolean;
+    /** How many rows differ from `allOpen`. */
+    get exceptionCount(): number;
+    /** The keys of the rows that differ from `allOpen`. */
+    exceptions(): unknown[];
+    /** Whether a row may have details, by `canExpand`. Reactive. */
+    canExpand(row: T): boolean;
+    /** Whether the row with this key text is open. Reactive. */
+    isOpen(id: string): boolean;
+    /** Opens or closes one row; returns whether it changed. */
+    setOpen(id: string, key: unknown, open: boolean): boolean;
+    /** Opens or closes every row. */
+    setAll(open: boolean): void;
+    /** Back to `autoExpandAll`. */
+    reset(): void;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Heights added under some rows (their open details), by position among the rows laid out. A position
+ * counts at its measured height, or at `estimate` until it has one. The sums before a position are
+ * kept in two Fenwick trees (how many are measured, and their heights), so a long list with many open
+ * rows still finds a row's offset in a few steps, and a new measurement changes one entry only.
+ */
+export declare class ExtraHeights {
+    readonly at: readonly number[];
+    /** What a position without a measured height counts as. */
+    estimate: number;
+    private readonly heights;
+    private readonly counted;
+    private readonly summed;
+    private measured;
+    private measuredSum;
+    /** `at`: the positions that get a height, ascending. */
+    constructor(at: readonly number[]);
+    get size(): number;
+    /** The slot of a position, or -1 when it has no added height. */
+    slotOf(position: number): number;
+    /** How many positions before `position` have an added height. */
+    countBefore(position: number): number;
+    /** Gives a slot its measured height (`undefined`: counted at the estimate again). */
+    set(slot: number, height: number | undefined): void;
+    /** The measured height of a slot, if it has one. */
+    measuredAt(slot: number): number | undefined;
+    /** The height added under a position (0 when it has none). */
+    heightAt(position: number): number;
+    /** The heights added under the positions before `position`. */
+    before(position: number): number;
+    /** The average of the measured heights, or `null` before any. */
+    get average(): number | null;
+}

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

@@ -0,0 +1,113 @@
+import { data } from '@motifx-community/data';
+import type { ColumnFilter } from '../column-filter';
+import type { GridFilterOperator } from '../grid-filter-operator';
+import type { GridFilters } from '../grid-filters';
+import type { ColumnModel } from './ColumnModel';
+/**
+ * The grid's filters by field: the filter row's condition and the header filter's values, the
+ * conditions of the filter value that no column shows (the filter builder's), and the search
+ * panel's filter. Turns them into one data-layer filter (`expression`), each column's part only
+ * while its feature is on, so switching a feature off takes its filter out. With `sync` the filter
+ * value holds the columns' parts too (`filterValue`), and a filter value given is shared out to the
+ * columns that can show its conditions. Reads are reactive per column.
+ */
+export declare class FilterModel<T> {
+    private readonly columns;
+    /** `fields` grows when a column's filter comes or goes; `search` and `extra` count changes of the other parts. */
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        fields: number;
+        search: number;
+        extra: number;
+        enabled: boolean;
+    };
+    /** The last change came from typing: wait `filterDelay` before applying it. */
+    typed: boolean;
+    /** How a column's header filter value filters when not by being equal (a range, an expression); the grid gives it. */
+    conditionOf: (field: string) => ((value: unknown) => data.FilterExpression | null) | null;
+    /** Whether the filter row and the header filters are part of the filter value (`filterSyncEnabled`); the grid gives it. */
+    sync: () => boolean;
+    private searchPart;
+    /** Conditions of the filter value no column shows, in order; with `sync` off, the whole filter value. */
+    private extraItems;
+    /** The header filter part each column last wrote into the filter value, to know it again. */
+    private readonly written;
+    /** Each column's filter; the values in it are kept as they were given. */
+    private readonly byField;
+    /** Grows when a column's filter changes. */
+    private readonly versions;
+    constructor(columns: ColumnModel<T>);
+    get(field: string): ColumnFilter | undefined;
+    /** Changes part of a column's filter. `typed` waits a moment before the grid applies it. */
+    update(field: string, change: Partial<ColumnFilter>, typed?: boolean): void;
+    /** Takes the filter row's value (or the header filter's values) of a column away; its condition stays. */
+    clear(field: string, part?: 'row' | 'values' | 'all'): void;
+    /** Forgets a column's filter, its condition too (the column went away). */
+    drop(field: string): void;
+    /** Every column's filter and the filter value's own conditions go; the conditions chosen in the filter row stay. */
+    clearAll(): void;
+    /** The search panel's filter, joined to the others (AND); `null` takes it away. */
+    setSearch(filter: data.FilterExpression | null): void;
+    /** The search panel's filter now. Reactive. */
+    search(): data.FilterExpression | null;
+    /** A copy of the filters that do something. */
+    toFilters(): GridFilters;
+    replace(filters: GridFilters): void;
+    /** Whether the column filters rows now (row part or values part). */
+    isActive(field: string): boolean;
+    hasValues(field: string): boolean;
+    /** Whether any filter but the search leaves rows out now. */
+    any(): boolean;
+    /** Whether the filter value applies (the filter panel's check box). Reactive. */
+    get enabled(): boolean;
+    set enabled(on: boolean);
+    /** The conditions of the filter value no column shows (with `sync` off, the whole filter value). Reactive. */
+    extra(): data.FilterExpression | null;
+    /**
+     * The filter value: with `sync`, every column's filter row condition and header filter values
+     * and the conditions no column shows, joined with AND; without, the filter value given alone.
+     * Dates are as they were chosen (a day, not its first and last moment). Reactive.
+     */
+    filterValue(): data.FilterExpression | null;
+    /**
+     * Takes a filter value. With `sync` its conditions (the items of a top AND) go to the filter row
+     * and the header filter of their column where those can show them, one each, and the rest is kept
+     * as the filter value's own; without, all of it is.
+     */
+    setFilterValue(value: data.FilterExpression | null): void;
+    /** The filter value's own conditions as they were, and whether it applied (a change put back). */
+    restoreValue(extra: data.FilterExpression | null, enabled: boolean): void;
+    /** The filter value goes; with `sync`, so do the columns' filters (their conditions stay). */
+    clearValue(): void;
+    private setExtra;
+    /** Every column's filter, followed: which columns have one and what each holds. */
+    private entries;
+    private versionOf;
+    /** Sets a column's filter, or takes it away (`undefined`); what reads it reads it again. */
+    private put;
+    /** Every column's filter at once: the ones left out go. */
+    private putAll;
+    /** Where a condition of a filter value shows: a column's filter row, or its header filter. */
+    private columnPartOf;
+    /** The filter row state that shows a condition, if the column's filter row can. */
+    private rowChangeOf;
+    /** The conditions the filter row offers for a column; none for a check box column and a lookup column (always `=`). */
+    operators(field: string): readonly GridFilterOperator[];
+    /** The condition of a column's filter row: its own, else the column's default. */
+    operator(field: string): GridFilterOperator;
+    /**
+     * Every column's filter, the filter value's own conditions and the search together (AND), as the
+     * data layer runs them; `skipValuesOf` leaves one column's header values out (for its own value
+     * list), `skipColumn` its whole filter (a lookup's lists honor only the other columns).
+     */
+    expression(skipValuesOf?: string, skipColumn?: string): data.FilterExpression | null;
+    /** A filter value's condition as the data layer runs it: a date column's by calendar day. */
+    applied(e: data.FilterExpression): data.FilterExpression | null;
+    /** The filter row's condition of a column as chosen (a day stays a day). */
+    private rowCondition;
+    private rowPart;
+    /** The header filter's part: any of the values (`in`, ranges, expressions, empty), or none of them with `filterType: 'exclude'`. */
+    private valuesPart;
+}

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

@@ -0,0 +1,47 @@
+import { data } from '@motifx-community/data';
+import type { FilterTreeNode } from './filter-tree-node';
+import type { GridModel } from './GridModel';
+import { LookupValues } from './LookupValues';
+import type { ValueList } from './value-list';
+import { ValueIntervals } from './ValueIntervals';
+/** The key of the tree's entry for empty values. */
+export declare const BLANK_NODE = "(blank)";
+/**
+ * Where a column's header filter gets its values: the app's `loadValues`, rows held in memory (the
+ * grid counts them itself, the column's `value` reader and format included), or an adapter that
+ * groups (one grouped load per part, with counts). Every way honors the other filters. A column can
+ * group them into ranges of numbers or parts of dates (`headerFilterInterval`, a tree for more than
+ * one level), counted in the browser from every distinct value, or give entries of its own
+ * (`headerFilterItems`).
+ */
+export declare class FilterValues<T> {
+    private readonly model;
+    /** The lists of the lookup columns. */
+    readonly lookups: LookupValues<T>;
+    constructor(model: GridModel<T>);
+    /** Whether the values of the column can be listed at all (a lookup column's always can: from its source; entries of its own always). */
+    available(field?: string): boolean;
+    /** Whether the list can search: always in memory, in a lookup column (by text), in ranges and in entries of its own; on a server, text columns only. */
+    searchable(field: string): boolean;
+    /** The ranges or date parts of a column's header filter, or `null` for one entry per value. Reactive. */
+    intervals(field: string): ValueIntervals | null;
+    /** A list of values, or a tree (date parts, ranges in more than one level). Reactive. */
+    kind(field: string): 'list' | 'tree';
+    /** How a kept value of a column filters, when not by being equal: a range, or an entry's own expression. Reactive. */
+    conditionOf(field: string): ((value: unknown) => data.FilterExpression | null) | null;
+    /** The list of a column's header filter, made for one opening. */
+    list(field: string): ValueList;
+    /** The tree of a column's header filter: its date parts or ranges, with the rows under each, empty values first. */
+    tree(field: string, signal: AbortSignal): Promise<FilterTreeNode[]>;
+    /** The entries a column gives itself, by their place in the list; a kept value is found by what it is. */
+    private ownList;
+    /** Every distinct value of the column under the other filters, grouped into its ranges or date parts. */
+    private buckets;
+    /** The text of a node: a year, Q2, a month's name, a day or a time part; "0 – 100" for a range. */
+    private partText;
+    /** The column's values the list would show, with their texts: for the app's own entries to start from. */
+    private distinctWithTexts;
+    private loader;
+    /** Every distinct value of the rows the other filters leave, with counts, empty first, then in order. */
+    private countValues;
+}