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

package/dist/components/datagrid/model/cell-corner.d.ts

@@ -0,0 +1,8 @@
+/** A corner of a cell range: the row by its id and key, the grid index it was last found at, the column. */
+export interface CellCorner {
+    /** The tracker's id of the row; `undefined` while the row was still loading. */
+    rowId: string | undefined;
+    key: unknown;
+    index: number;
+    field: string;
+}

package/dist/components/datagrid/model/cell-range-entry.d.ts

@@ -0,0 +1,7 @@
+import type { CellCorner } from './cell-corner';
+/** A range as the grid keeps it: where it was started, its far corner, and the columns it covers. */
+export interface CellRangeEntry {
+    anchor: CellCorner;
+    extent: CellCorner;
+    fields: string[];
+}

package/dist/components/datagrid/model/cell-value.d.ts

@@ -0,0 +1,3 @@
+import type { GridColumn } from '../grid-column';
+/** The raw value of a column in a row: its `value` reader, else the field. Read untracked: the row is the developer's, plain or reactive. */
+export declare function cellValue<T>(col: GridColumn<T>, row: T | undefined): unknown;

package/dist/components/datagrid/model/clipboard-content.d.ts

@@ -0,0 +1,11 @@
+/** What Ctrl+C puts on the clipboard. */
+export interface ClipboardContent {
+    /** Tab-separated lines (one cell: its text alone). */
+    text: string;
+    /** The same as an HTML table. */
+    html: string;
+    /** Rows copied; 0 for the active cell. */
+    rows: number;
+    /** Cells of the cell ranges copied; 0 for rows or the active cell. */
+    cells: number;
+}

package/dist/components/datagrid/model/column-feature-names.d.ts

@@ -0,0 +1,2 @@
+/** The features a column definition can turn on or off for itself. */
+export declare const COLUMN_FEATURES: readonly ["editable", "creatable", "sortable", "resizable", "movable", "hideable", "pinnable", "menu", "filterRow", "headerFilter", "filterBuilder", "copyable", "cellSelectable", "exportable", "syncLookupFilterValues", "searchable", "groupable", "showWhenGrouped", "allowCollapsing", "groupCount", "groupMenu"];

package/dist/components/datagrid/model/column-zone.d.ts

@@ -0,0 +1,3 @@
+import type { StickySide } from '../sticky-side';
+/** The part of the row a column sits in: pinned to an edge, or with the columns that scroll. */
+export type ColumnZone = StickySide | 'free';

package/dist/components/datagrid/model/data-state.d.ts

@@ -0,0 +1,11 @@
+/** The part of the grid's reactive state the data writes. */
+export interface DataState {
+    /** `loading` until the first rows of a query arrive; `error` when they could not be loaded. */
+    status: 'loading' | 'ready' | 'error';
+    /** Grows whenever rows arrive, change or change place. */
+    version: number;
+    /** Grows whenever an unsaved value, a mark or a message changes. */
+    edits: number;
+    /** Blocks that failed after the first answer. */
+    failedBlocks: number;
+}

package/dist/components/datagrid/model/date-like.d.ts

@@ -0,0 +1,2 @@
+/** A date back in the kind of value a cell had: a `Date`, a timestamp, or a `yyyy-mm-dd` text. */
+export declare function dateLike(date: Date | null, like: unknown): unknown;

package/dist/components/datagrid/model/day-condition.d.ts

@@ -0,0 +1,6 @@
+import { data } from '@motifx-community/data';
+import type { GridFilterOperator } from '../grid-filter-operator';
+/** A date condition by calendar day, whatever time the values carry. */
+export declare function dayCondition(field: string, op: GridFilterOperator, value: unknown): data.FilterExpression | null;
+export declare function dayStart(v: unknown): Date | null;
+export declare function dayEnd(v: unknown): Date | null;

package/dist/components/datagrid/model/default-settings.d.ts

@@ -0,0 +1,2 @@
+import type { GridSettings } from '../grid-settings';
+export declare const DEFAULT_SETTINGS: GridSettings;

package/dist/components/datagrid/model/delimited-text.d.ts

@@ -0,0 +1,4 @@
+/** Rows of cells as delimited text (tab-separated for the clipboard, CSV): a cell with the separator, a quote or a line break is quoted, its quotes doubled. */
+export declare function writeDelimited(rows: readonly (readonly string[])[], separator: string): string;
+/** Delimited text back into rows of cells. A cell that starts with a quote runs to its closing quote, line breaks included; the last line break is not a row. */
+export declare function readDelimited(text: string, separator: string): string[][];

package/dist/components/datagrid/model/export-table.d.ts

@@ -0,0 +1,20 @@
+/** Rows ready to export: the fields in display order and one array of cell values per row. */
+export interface ExportTable {
+    fields: string[];
+    rows: unknown[][];
+    /** Grouped: a line per group, before the row it starts at: its "Column: value" text with its summary items, and items under their columns. */
+    groups?: {
+        at: number;
+        text: string;
+        level: number;
+        cells: string[];
+    }[];
+    /** Grouped: a footer line per group, after the row its rows end at (inner groups first), by field. */
+    footers?: {
+        at: number;
+        level: number;
+        cells: string[];
+    }[];
+    /** The row of totals, by field. */
+    total?: string[];
+}

package/dist/components/datagrid/model/filter-tree-node.d.ts

@@ -0,0 +1,11 @@
+/** An entry of a header filter's tree: a part of a date or a range of numbers, with the rows under it. */
+export interface FilterTreeNode {
+    /** The key the tree keeps it under. */
+    id: string;
+    /** What the column's filter keeps for it: `2024`, `'2024/3'`, a range's start, or `null` for empty values. */
+    value: unknown;
+    text: string;
+    /** Rows under it, when the values come with counts. */
+    count?: number;
+    children?: FilterTreeNode[];
+}

package/dist/components/datagrid/model/filter-value-state.d.ts

@@ -0,0 +1,8 @@
+import type { data } from '@motifx-community/data';
+/** The grid's filter value at one moment: the value, its own conditions, whether it applies, and a key to compare. */
+export interface FilterValueState {
+    value: data.FilterExpression | null;
+    extra: data.FilterExpression | null;
+    enabled: boolean;
+    key: string;
+}

package/dist/components/datagrid/model/formula-guard.d.ts

@@ -0,0 +1,2 @@
+/** Text a spreadsheet would run as a formula (it starts with `=`, `+`, `-`, `@`, a tab or a return) with a `'` in front, so it stays text. */
+export declare function guardFormula(text: string): string;

package/dist/components/datagrid/model/grid-data-options.d.ts

@@ -0,0 +1,42 @@
+import type { data } from '@motifx-community/data';
+import type { DataState } from './data-state';
+import type { GroupLevel } from './group-level';
+import type { GroupNode } from './group-node';
+/** What `GridData` is made of. */
+export interface GridDataOptions<T> {
+    source: data.DataSource<T, unknown>;
+    /** The grid made the source (for its `rows`) and disposes it. */
+    owned: boolean;
+    paged: boolean;
+    /** The rows show part by part, the next one as the view nears the end (a source that loads by page stays paged). */
+    infinite?: boolean;
+    /** Infinite: a part came, `count` rows from `skip`. */
+    partLoaded?: (skip: number, count: number) => void;
+    /** Rows per page when the grid pages rows it holds itself. */
+    pageSize: number;
+    /** Rows per page the user chose (the pager's page sizes), over the source's own; `null` for none. 0: every row on one page. */
+    chosenPageSize?: number | null;
+    /** The sort the rows start with (as the source names the fields). */
+    sort: readonly data.SortItem[];
+    /** The levels the rows start grouped by; none for plain rows. */
+    group: readonly GroupLevel[];
+    /** Who groups the rows (`remoteGrouping`), and rows per request while every row loads for memory. */
+    remoteGrouping: 'auto' | boolean;
+    groupLoadPageSize: number;
+    /** Whether a group is open. */
+    expanded: (node: GroupNode) => boolean;
+    /** Whether each open group ends with a footer row. */
+    footers: () => boolean;
+    /** The group summaries a server is asked for with its groups; `null` when they can only be computed in memory, which then groups the rows. */
+    groupSummary: () => readonly data.SummaryItem[] | null;
+    /** The locale group keys are compared in. */
+    locale: () => string | undefined;
+    saveMode: data.SaveMode;
+    createRow?: () => Partial<T>;
+    validateRow: data.ChangeTrackerOptions<T, unknown>['validateRow'];
+    state: DataState;
+    /** Fields of `state` were changed: the grid tells its views. */
+    changed?: (...fields: (keyof DataState & string)[]) => void;
+    /** The tracker told something; the grid keeps its new-row area in step. */
+    edited: (change: data.ChangeTrackerChange<T>) => void;
+}

package/dist/components/datagrid/model/grid-state.d.ts

@@ -0,0 +1,41 @@
+import type { data } from '@motifx-community/data';
+import type { Adjustment } from './adjustment';
+import type { DataState } from './data-state';
+/** The grid's shared reactive state. */
+export interface GridState extends DataState {
+    sort: data.SortItem[];
+    /** The page shown (paged mode), 0-based. */
+    page: number;
+    /** Rows per page (paged mode); 0: every row on one page. */
+    pageSize: number;
+    rowHeight: number;
+    /** Visible height of the body (viewport minus header). */
+    viewport: number;
+    /** Inner width of the viewport, for the columns the width hides; 0 until measured. */
+    width: number;
+    /** The body has been measured: the rows drawn are the ones on the screen (lookup cells ask for their keys from then on). */
+    measured: boolean;
+    activeRow: number;
+    activeField: string;
+    /** The user has moved the active cell; until then it follows the data (header ↔ first row). */
+    touched: boolean;
+    adjust: Adjustment | null;
+    announcement: string;
+    /** Rows in the new-row area (the rows themselves stay out of reactive state: the tracker knows them by identity). */
+    added: number;
+    /** The row the user is in with edits not sent yet (its id), or `null`. */
+    session: string | null;
+    /** The cell in edit mode, or `null`. */
+    editing: {
+        rowId: string;
+        field: string;
+    } | null;
+    /** A row is being saved and the grid waits for it (`wait` mode): no navigation. */
+    busy: boolean;
+    /** Grows when the grid starts again with other data. */
+    connection: number;
+    /** An export is collecting rows. */
+    exporting: boolean;
+    /** An action is working on rows and the grid waits for it (a promise came back). */
+    acting: boolean;
+}

package/dist/components/datagrid/model/group-item-entry.d.ts

@@ -0,0 +1,11 @@
+import type { GroupNode } from './group-node';
+/** What sits at a place of the grouped list: a group's row or its footer, or a data row by its index in group order. */
+export type GroupItemEntry = {
+    node: GroupNode;
+    data: -1;
+    footer: boolean;
+} | {
+    node: null;
+    data: number;
+    footer: false;
+};

package/dist/components/datagrid/model/group-level.d.ts

@@ -0,0 +1,12 @@
+/** A level the grid groups its rows by, as its data needs it. */
+export interface GroupLevel {
+    /** The grouped column. */
+    field: string;
+    dir: 'asc' | 'desc';
+    /** The field a server groups by (a text `calculateGroupValue` or `textFrom`, else the column's); `null` when only memory can (a function reads the value). */
+    serverField: string | null;
+    /** How memory reads the value to group by; `undefined` reads the field. */
+    read: ((row: unknown) => unknown) | undefined;
+    /** How memory orders the groups (`groupCompare`); `undefined` by their values. */
+    compare: ((a: unknown, b: unknown) => number) | undefined;
+}

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

@@ -0,0 +1,21 @@
+/** A group of the grid's rows: its key in its level, how many rows it holds and where they start. */
+export interface GroupNode {
+    /** The keys from the top level down, as one text: it names the group across loads. */
+    id: string;
+    /** 0 for the top level. */
+    level: number;
+    /** The grouped column. */
+    field: string;
+    /** The value its rows share; `null` for empty values. */
+    key: unknown;
+    /** The keys from the top level down to this group. */
+    path: unknown[];
+    /** Rows in the group, all levels below included. */
+    count: number;
+    /** Index of its first row among the rows in group order. */
+    start: number;
+    /** The groups of the next level; `null` in the last level, whose rows come next. */
+    children: GroupNode[] | null;
+    /** The group summary values a server gave with the group, in the order they were asked for. */
+    summary?: unknown[];
+}

package/dist/components/datagrid/model/group-nodes.d.ts

@@ -0,0 +1,7 @@
+import type { data } from '@motifx-community/data';
+import type { GroupLevel } from './group-level';
+import type { GroupNode } from './group-node';
+/** The id of a group by its keys from the top level down; text keys without case, as they group. */
+export declare function groupId(path: readonly unknown[], locale?: string): string;
+/** The groups of the data layer as the grid keeps them: ids, paths and where each one's rows start. */
+export declare function groupNodes(groups: readonly data.RowGroup<unknown>[], levels: readonly GroupLevel[], locale?: string): GroupNode[];

package/dist/components/datagrid/model/html-table.d.ts

@@ -0,0 +1,2 @@
+/** Rows of cells as an HTML table, for the clipboard: word processors and spreadsheets paste it as a table. */
+export declare function htmlTable(head: readonly string[] | null, rows: readonly (readonly string[])[]): string;

package/dist/components/datagrid/model/list-separator.d.ts

@@ -0,0 +1,2 @@
+/** The CSV field separator spreadsheets expect in a locale: `;` where decimals are written with a comma, else `,`. */
+export declare function listSeparator(locale: string): string;

package/dist/components/datagrid/model/lookup-cell.d.ts

@@ -0,0 +1,7 @@
+/** What a lookup cell shows: its text, and whether the key is found, still loading, not in the source, or empty. */
+export interface LookupCell {
+    text: string;
+    state: 'found' | 'loading' | 'missing' | 'none';
+    /** The tooltip of a key the source does not have. */
+    hint?: string;
+}

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

@@ -0,0 +1,16 @@
+import type { DetailContext } from '../detail-context';
+/** The `masterDetail` options as the grid reads them: values, not getters. */
+export interface MasterDetailValues<T> {
+    enabled: boolean;
+    autoExpandAll: boolean;
+    template: ((ctx: DetailContext<T>) => unknown) | undefined;
+    canExpand: boolean | ((row: T) => boolean);
+    keepDetails: boolean;
+    keepAcrossPages: boolean;
+    height: number | ((row: T) => number) | undefined;
+    estimatedHeight: number;
+    keepLimit: number;
+    columnWidth: number;
+    toggleKeys: readonly string[];
+    arrowKeys: boolean;
+}

package/dist/components/datagrid/model/nothing-entered.d.ts

@@ -0,0 +1,3 @@
+import { data } from '@motifx-community/data';
+/** The context of a row nothing was entered in (or of no row): every value is the row's own. */
+export declare function nothingEntered<T>(row: T | null | undefined): data.RowCheckContext<T>;

package/dist/components/datagrid/model/option-of.d.ts

@@ -0,0 +1,6 @@
+import type { ListOption } from '../list-option';
+/** The value and display text of a list option. */
+export declare function optionOf(o: ListOption): {
+    value: unknown;
+    label: string;
+};

package/dist/components/datagrid/model/parse-date-text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A date written as text: ISO (`2026-10-25`, with a time too) or in the locale's order of day, month
+ * and year with any separators (`25.10.2026`, `10/25/26`); a two-digit year is in this century.
+ * `null` when it is not a real date.
+ */
+export declare function parseDateText(text: string, locale: string): Date | null;

package/dist/components/datagrid/model/paste-result.d.ts

@@ -0,0 +1,9 @@
+/** What a paste wrote. */
+export interface PasteResult {
+    /** Ids of the rows written into, in order (new rows opened for the paste included). */
+    rowIds: string[];
+    /** Cells that took a value. */
+    cells: number;
+    /** Cells whose text could not be read; they show the message. */
+    failed: number;
+}

package/dist/components/datagrid/model/placed-item.d.ts

@@ -0,0 +1,19 @@
+import type { GridGroupSummaryItem } from '../grid-group-summary-item';
+import type { GridSummaryType } from '../grid-summary-type';
+/** A summary item as the grid reads it now: its fields with the defaults in. */
+export interface PlacedItem {
+    /** Its place in `totalItems` or `groupItems`, and in the values. */
+    index: number;
+    item: GridGroupSummaryItem;
+    type: GridSummaryType;
+    /** The column aggregated; `undefined` without one. */
+    field: string | undefined;
+    /** The column it shows under. */
+    place: string | undefined;
+    name: string | undefined;
+    /** A group item in the group footer. */
+    footer: boolean;
+    /** A group item under its column in the group row. */
+    align: boolean;
+    visible: boolean;
+}

package/dist/components/datagrid/model/range-box.d.ts

@@ -0,0 +1,8 @@
+/** A range found in the rows shown now: its first and last grid rows (data rows), its columns, its anchor. */
+export interface RangeBox {
+    top: number;
+    bottom: number;
+    fields: Set<string>;
+    anchorRow: number;
+    anchorField: string;
+}

package/dist/components/datagrid/model/range-look.d.ts

@@ -0,0 +1,18 @@
+import type { RangeBox } from './range-box';
+/** What the rows need to draw the cell ranges and a drag's run, worked out once per change for all of them. */
+export interface RangeLook {
+    /** Cells can be selected (`cellSelection` is on). */
+    on: boolean;
+    boxes: RangeBox[];
+    /** The visible data columns, in display order. */
+    shown: string[];
+    /** The columns whose cells can be selected. */
+    selectable: Set<string>;
+    /** The rows a drag selects now, and the first and last visible columns the run's frame goes to. */
+    run: {
+        top: number;
+        bottom: number;
+    } | null;
+    first: string;
+    last: string;
+}

package/dist/components/datagrid/model/read-field.d.ts

@@ -0,0 +1,5 @@
+type ValueOf<F> = F extends (...args: never[]) => infer V ? V : F;
+/** A field of an object the developer gave, read untracked (`givenField`), typed: a `Bind<V>` field gives `V`. */
+export declare function readField<O extends object, K extends keyof O>(owner: O, key: K): ValueOf<O[K]>;
+export declare function readField<O extends object, K extends keyof O>(owner: O | null | undefined, key: K): ValueOf<O[K]> | undefined;
+export {};

package/dist/components/datagrid/model/row-dragging-values.d.ts

@@ -0,0 +1,24 @@
+/** The `rowDragging` options as the grid reads them: values, not getters (the handlers are kept apart). */
+export interface RowDraggingValues {
+    allowReordering: boolean;
+    allowDropInsideItem: boolean;
+    dropFeedbackMode: 'indicate' | 'push';
+    showDragIcons: boolean;
+    handle: string;
+    group: string | undefined;
+    data: unknown;
+    dragDirection: 'both' | 'vertical' | 'horizontal';
+    boundary: string | HTMLElement | undefined;
+    container: string | HTMLElement | undefined;
+    cursorOffset: {
+        x?: number;
+        y?: number;
+    } | string | undefined;
+    autoScroll: boolean;
+    scrollSpeed: number;
+    scrollSensitivity: number;
+    keyboard: boolean;
+    moveUpKeys: readonly string[];
+    moveDownKeys: readonly string[];
+    columnWidth: number;
+}

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

@@ -0,0 +1,2 @@
+/** A run of grid rows `[from, to)` shown one after the other. */
+export type RowRun = [number, number];

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

@@ -0,0 +1,2 @@
+/** What a row's status cell shows. */
+export type RowStatus = '' | 'new' | 'changed' | 'removed' | 'saving' | 'failed' | 'invalid';

package/dist/components/datagrid/model/rows-sorting.d.ts

@@ -0,0 +1,7 @@
+import type { data } from '@motifx-community/data';
+/** How the grid's rows in memory are read for sorting, and what is waited for before they are sorted. */
+export interface RowsSorting<T> {
+    /** The reader of a column for sorting; `undefined` reads the field. */
+    sortValue: (field: string) => ((row: T) => unknown) | undefined;
+    beforeSort: (sort: readonly data.SortItem[], rows: readonly T[]) => Promise<void>;
+}

package/dist/components/datagrid/model/run-panel.d.ts

@@ -0,0 +1,7 @@
+/** The panel over the rows while an action works on several rows: what it says, how far it got, Stop. */
+export interface RunPanel {
+    /** Shows the panel; whether it shows (another job may hold it). */
+    open(text: string, stop: () => void): boolean;
+    progress(done: number, total: number): void;
+    close(): void;
+}

package/dist/components/datagrid/model/same-value.d.ts

@@ -0,0 +1,2 @@
+/** Two cell values are the same: empty ones (`null`, `undefined`, `''`) alike, dates by moment. */
+export declare function sameValue(a: unknown, b: unknown): boolean;

package/dist/components/datagrid/model/sticky-offset.d.ts

@@ -0,0 +1,8 @@
+import type { StickySide } from '../sticky-side';
+/** Where a sticky column sits and how far from its edge. */
+export interface StickyOffset {
+    side: StickySide;
+    offset: number;
+    /** The column next to the scrolling area (draws the separator). */
+    edge: boolean;
+}

package/dist/components/datagrid/model/stored-layout.d.ts

@@ -0,0 +1,15 @@
+import type { data } from '@motifx-community/data';
+import type { GridFilters } from '../grid-filters';
+import type { GridLayout } from '../grid-layout';
+/** What a grid with a `layoutKey` keeps in the browser's storage. */
+export interface StoredLayout extends GridLayout {
+    filters: GridFilters;
+    /** The filter value (the filter builder's conditions; with sync, the columns' filters too). */
+    filterValue?: data.FilterExpression | null;
+    /** Whether the filter value applies. */
+    filterEnabled?: boolean;
+    /** The search panel's text. */
+    searchText?: string;
+    /** The rows per page the user chose. */
+    pageSize?: number;
+}

package/dist/components/datagrid/model/summary-part.d.ts

@@ -0,0 +1,7 @@
+/** A summary item ready to draw: its text, the text that names its column, its alignment and class. */
+export interface SummaryPart {
+    text: string;
+    label: string;
+    align: 'start' | 'center' | 'end' | undefined;
+    cssClass: string | undefined;
+}

package/dist/components/datagrid/model/text-ranges.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Where `needle` occurs in `text`, as `[start, end)` pairs, without case in the locale unless
+ * `caseSensitive`. Letters whose lower case is longer (`İ` outside Turkish) still map back to their
+ * place in `text`.
+ */
+export declare function textRanges(text: string, needle: string, locale: string, caseSensitive: boolean): [number, number][];

package/dist/components/datagrid/model/value-list.d.ts

@@ -0,0 +1,12 @@
+import type { data } from '@motifx-community/data';
+import type { GridFilterValue } from '../grid-filter-value';
+/** A header filter's list for one opening: its source, and how its entries map to the values the filter keeps. */
+export interface ValueList {
+    source: data.DataSource<GridFilterValue, unknown>;
+    /** The entry of a value the filter keeps. */
+    toEntry(value: unknown): unknown;
+    /** The value the filter keeps for an entry. */
+    toValue(entry: unknown): unknown;
+    /** Every entry the list offers, without a search. */
+    all(): Promise<unknown[]>;
+}

package/dist/components/datagrid/model/value-loader.d.ts

@@ -0,0 +1,8 @@
+import type { GridValuesResult } from '../grid-values-result';
+/** Asks for a part of a column's values; `search` is the text of the list's search box. */
+export type ValueLoader = (request: {
+    search: string;
+    skip: number;
+    take: number;
+    signal: AbortSignal;
+}) => Promise<GridValuesResult>;

package/dist/components/datagrid/new-row-options.d.ts

@@ -0,0 +1,8 @@
+import type { Bind } from '@motifx/core';
+/** Where new rows open and what they start with. */
+export interface NewRowOptions<T> {
+    /** `'bottom'` (default) below the last row, or `'top'` above the first. */
+    position?: Bind<'top' | 'bottom'>;
+    /** Initial values of a new row. */
+    create?: () => Partial<T>;
+}

package/dist/components/datagrid/row-change.d.ts

@@ -0,0 +1,7 @@
+/** A new or updated row as `grid.changes` lists it. */
+export interface RowChange<T> {
+    /** The row itself, as the data has it (the changes are not in it until they are saved). */
+    row: T;
+    /** Only the changed fields and their new values. */
+    changed: Partial<T>;
+}

package/dist/components/datagrid/row-state.d.ts

@@ -0,0 +1,17 @@
+/** What a row is going through, given to `actions` and to an action's `visible` and `disabled`. */
+export interface RowState {
+    /** Added in the grid and never saved. */
+    readonly isNew: boolean;
+    /** The user is in this row with edits not sent yet, or has its editor open. */
+    readonly isEditing: boolean;
+    /** Has unsaved values. */
+    readonly isDirty: boolean;
+    readonly isSaving: boolean;
+    /** The last save failed, or a value has a message. */
+    readonly hasError: boolean;
+    /** Marked for deletion (batch mode), or being deleted. */
+    readonly isRemoved: boolean;
+    readonly isSelected: boolean;
+    /** Index of the row in the grid (new rows included). */
+    readonly index: number;
+}

package/dist/components/datagrid/selection-mode.d.ts

@@ -0,0 +1,2 @@
+/** How many rows can be selected. */
+export type SelectionMode = 'none' | 'single' | 'multiple';

package/dist/components/datagrid/sticky-side.d.ts

@@ -0,0 +1,2 @@
+/** Which edge a column sticks to while the grid scrolls sideways. */
+export type StickySide = 'start' | 'end';

package/dist/components/datagrid/view/ActionWidths.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedAction } from './resolved-action';
+/**
+ * Widths of action buttons, measured once per action (its id, text and look) in a hidden cell and
+ * kept, so fitting a row's buttons only adds numbers: scrolling triggers no layout. A width of 0
+ * (the grid is not shown yet) is not kept.
+ */
+export declare class ActionWidths {
+    private readonly host;
+    private readonly widths;
+    private frameSize;
+    private box;
+    constructor(host: () => HTMLElement | null);
+    /** Measure again (the density changed). */
+    clear(): void;
+    width<T>(a: ResolvedAction<T>): number;
+    /** The cell's padding (both sides), the gap between buttons and the width of the "more" button. */
+    frame(): {
+        padding: number;
+        gap: number;
+        more: number;
+    };
+    private cell;
+}