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

package/dist/components/datagrid/grid-edit-canceling-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { EventArgs } from '@motifx/core';
+/**
+ * Unsaved changes are about to be dropped: Escape on a row, a row's "Cancel" action, `discardChanges()`.
+ * `rows` are the rows whose edits go (a new row goes away); `cancel` keeps them.
+ */
+export interface GridEditCancelingEventArgs<T> extends EventArgs {
+    readonly rows: readonly T[];
+}

package/dist/components/datagrid/grid-edit-form.d.ts

@@ -0,0 +1,22 @@
+import type { Bind } from '@motifx/core';
+import type { FieldLabelMode } from '../../parts/field/field-label-mode';
+import type { FormItem } from '../formlayout/form-item';
+/**
+ * The edit form of `editMode` `'form'` and `'popup'`, laid out by the kit's `FormLayout`. Read and
+ * change it later through `grid.form`.
+ */
+export interface GridEditForm {
+    /**
+     * What the form holds, in order: a column by its field name, or a kit form item. An item whose
+     * `field` is a column's gets that column's editor, with the item's `label`, `colSpan`, `helpText`,
+     * `visible` and `editorProps`; groups (`group`, `items`, `columns`), buttons and `template`s are
+     * the form's own. Default: every column, in the columns' order (`formItem.order` first).
+     */
+    items?: Bind<readonly (string | FormItem)[] | undefined>;
+    /** Columns of the form. Default `2`. */
+    colCount?: Bind<number>;
+    /** With it, as many columns as fit, each at least this wide (a CSS length); `colCount` is the most. */
+    minColWidth?: Bind<string>;
+    /** Where the labels go. Default `'top'`. */
+    labelMode?: Bind<FieldLabelMode>;
+}

package/dist/components/datagrid/grid-edit-popup.d.ts

@@ -0,0 +1,22 @@
+import type { Bind } from '@motifx/core';
+/** The modal window of `editMode: 'popup'`, the kit's `MxForm`. Read and change it later through `grid.popup`. */
+export interface GridEditPopup {
+    /** Default: the `gridEditRowTitle` text of `uiLocale` (`gridNewRowTitle` for a new row). */
+    title?: Bind<string>;
+    /** The title shows in the title bar; off, it still names the window for screen readers. Default `true`. */
+    showTitle?: Bind<boolean>;
+    /** A CSS length; a number is pixels. Default: as wide as the form needs. */
+    width?: Bind<number | string>;
+    /** A CSS length; a number is pixels. Default: as tall as the form needs. */
+    height?: Bind<number | string>;
+    /** Resized from its edges. Default `true`. */
+    resizable?: Bind<boolean>;
+    /** Moved by its title bar. Default `true`. */
+    movable?: Bind<boolean>;
+    /** The close button in the title bar (it cancels, like Cancel). Default `true`. */
+    showCloseButton?: Bind<boolean>;
+    /** The maximize button. Default `false`. */
+    showMaximize?: Bind<boolean>;
+    /** Opens maximized, filling the viewport. Default `false`. */
+    fullScreen?: Bind<boolean>;
+}

package/dist/components/datagrid/grid-editing-cell.d.ts

@@ -0,0 +1,6 @@
+/** The cell whose editor is open. */
+export interface GridEditingCell<T> {
+    readonly rowIndex: number;
+    readonly field: string;
+    readonly row: T;
+}

package/dist/components/datagrid/grid-editing-start-event-args.d.ts

@@ -0,0 +1,14 @@
+import type { EventArgs } from '@motifx/core';
+/** A cell is about to be edited (its editor opens), or a row in its edit form; `cancel` keeps it as it is. */
+export interface GridEditingStartEventArgs<T> extends EventArgs {
+    /** The cell's field; `''` when the edit form opens for the whole row. */
+    readonly field: string;
+    /** The row itself. */
+    readonly row: T;
+    /** The values entered and not saved yet, by field (`{}` while there are none); the row itself does not hold them. */
+    readonly values: Readonly<Partial<T>>;
+    /** The value a field is saved with: the entered one when there is one, else the row's. */
+    getValue(field: string): unknown;
+    readonly rowIndex: number;
+    readonly isNew: boolean;
+}

package/dist/components/datagrid/grid-editor-prepared-event-args.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentBase } from '@motifx/core';
+/** An editor was made, in a cell or in the edit form: set it up further (it is disposed when the edit ends). */
+export interface GridEditorPreparedEventArgs<T> {
+    readonly field: string;
+    /** The row itself. */
+    readonly row: T;
+    /** The values entered and not saved yet, by field (`{}` while there are none); the row itself does not hold them. */
+    readonly values: Readonly<Partial<T>>;
+    /** The value a field is saved with: the entered one when there is one, else the row's. */
+    getValue(field: string): unknown;
+    readonly isNew: boolean;
+    /** The kit's editor, or the column's own `editor` content when it is a component. */
+    readonly editor: ComponentBase | null;
+    /** The element that holds it. */
+    readonly element: HTMLElement;
+    /** `'cell'`, `'form'` for the edit form (`editMode` `'form'` and `'popup'`), or `'adaptive'` for a row's adaptive detail. */
+    readonly place: 'cell' | 'form' | 'adaptive';
+}

package/dist/components/datagrid/grid-editor-preparing-event-args.d.ts

@@ -0,0 +1,19 @@
+import type { EventArgs } from '@motifx/core';
+/**
+ * An editor of a cell or of an edit form field is about to be made. `options` are the props the
+ * editor gets: change them (`enabled = false` disables it, `clearButton`, `placeholder`…); `cancel`
+ * keeps the cell from being edited, or leaves the field out of the form.
+ */
+export interface GridEditorPreparingEventArgs<T> extends EventArgs {
+    readonly field: string;
+    /** The row itself. */
+    readonly row: T;
+    /** The values entered and not saved yet, by field (`{}` while there are none); the row itself does not hold them. */
+    readonly values: Readonly<Partial<T>>;
+    /** The value a field is saved with: the entered one when there is one, else the row's. */
+    getValue(field: string): unknown;
+    /** The row was added in the grid and never saved. */
+    readonly isNew: boolean;
+    /** Props of the kit's editor (`TextBox`, `NumberBox`, `DateBox`, `CheckBox`, `DropDown`, `ComboBox`, `Lookup`); empty for a column's own `editor`. */
+    options: Record<string, unknown>;
+}

package/dist/components/datagrid/grid-export-cell.d.ts

@@ -0,0 +1,26 @@
+import type { GridBand } from './grid-band';
+import type { GridColumn } from './grid-column';
+/**
+ * A cell of the grid as an export sees it, handed to `customizeCell` with the cell written
+ * (DevExtreme's `ExcelDataGridCell`).
+ */
+export interface GridExportCell<T = any> {
+    readonly rowType: 'header' | 'group' | 'data' | 'groupFooter' | 'totalFooter';
+    /** The cell's column; in a group row's first cell, the grouped column. */
+    readonly column?: GridColumn<T>;
+    /** A header cell of a band's row: the band it shows (or lies under). */
+    readonly band?: GridBand<T>;
+    /** The row object of a data cell. */
+    readonly data?: T;
+    /** The raw value: a data cell's value, a group's key, a summary item's value. */
+    readonly value?: unknown;
+    /** The level of a group row, 0 for the top. */
+    readonly groupIndex?: number;
+    /** The group summary items the cell shows: in the group text (first cell) or under their column. */
+    readonly groupSummaryItems?: readonly {
+        name: string | undefined;
+        value: unknown;
+    }[];
+    /** The summary item a footer cell shows: its `name`, else `type_column`. */
+    readonly totalSummaryItemName?: string;
+}

package/dist/components/datagrid/grid-export-options.d.ts

@@ -0,0 +1,35 @@
+import type { GridLoadPanel } from './grid-load-panel';
+/** How `exportCsv()` and `exportRows()` write the rows. Every field has a default. */
+export interface GridExportOptions {
+    /** The text the cells show, or their values (numbers and dates in a neutral form). Default `'shown'`. */
+    values?: 'shown' | 'raw';
+    /** Only the selected rows ("all" selected over a server: the filter less the rows taken out). Default `false`. */
+    selected?: boolean;
+    /** Rows asked for per request when the data comes from a server. Default `1000`. */
+    pageSize?: number;
+    /** Told after each part arrives. */
+    onProgress?: (loaded: number, total: number) => void;
+    signal?: AbortSignal;
+    /** The panel over the rows while it runs, with its progress and a button that stops it; `true` turns it on. Default off. */
+    loadPanel?: boolean | GridLoadPanel;
+    /** CSV: the file name. Default: the grid's label, or `export`, with `.csv`. */
+    fileName?: string;
+    /** CSV: save the file (else only the text is returned). Default `true`. */
+    download?: boolean;
+    /** CSV: the field separator. Default: `;` where the locale writes decimals with a comma, else `,`. */
+    separator?: string;
+    /** CSV, while grouped: a "Column: value" line before each group. Default `true`. */
+    groups?: boolean;
+    /**
+     * The summaries as the grid shows them: each group's footer line after its rows, the row of totals
+     * last (as objects of the same fields in `exportRows()`), and the group summary items on the group
+     * lines. Several items of one column share a cell, one per line. Not with `selected`. Default `true`.
+     */
+    summaries?: boolean;
+    /** CSV: a first line of column titles. Default `true`. */
+    headers?: boolean;
+    /** CSV: start with a byte order mark so spreadsheets read UTF-8. Default `true`. */
+    bom?: boolean;
+    /** CSV: text that a spreadsheet would run as a formula (`=`, `+`, `-`, `@`) gets a `'` in front. Default `true`. */
+    escapeFormulas?: boolean;
+}

package/dist/components/datagrid/grid-export-settings.d.ts

@@ -0,0 +1,19 @@
+import type { Bind } from '@motifx/core';
+import type { GridExportTexts } from './grid-export-texts';
+/**
+ * The `export` prop: what the toolbar's export button (`settings.exportButton`) offers. With one
+ * command the button runs it; with more it opens a menu of them. `'csv'` is written by the grid;
+ * any other format raises `onExporting` with that `format`, where you write the file
+ * (`exportDataGrid` of `@motifx-community/ui/excel` for `'xlsx'`, of `/pdf` for `'pdf'`). Every field is a value or a function that is followed; read and
+ * change it later through `grid.export`.
+ *
+ * @example
+ * export={{ formats: ['xlsx', 'csv'], allowExportSelectedData: true }}
+ */
+export interface GridExportSettings {
+    /** The formats offered, in order. Default `['csv']`. */
+    formats?: Bind<readonly string[] | undefined>;
+    /** An "Export selected rows" command for each format (with a selection mode on). Default `false`. */
+    allowExportSelectedData?: Bind<boolean | undefined>;
+    texts?: Bind<GridExportTexts | undefined>;
+}

package/dist/components/datagrid/grid-export-texts.d.ts

@@ -0,0 +1,11 @@
+/** Texts of the toolbar's export button, over the `gridExport…` texts of `uiLocale`; `{format}` is the format's name. */
+export interface GridExportTexts {
+    /** The button's name when it opens a menu. Default "Export". */
+    exportTo?: string;
+    /** Default "Export all data to {format}". */
+    exportAll?: string;
+    /** Default "Export selected rows to {format}". */
+    exportSelectedRows?: string;
+    /** Names of the formats by their code, over "Excel", "CSV" and "PDF". */
+    formats?: Readonly<Record<string, string>>;
+}

package/dist/components/datagrid/grid-exported-event-args.d.ts

@@ -0,0 +1,8 @@
+/** An export finished. */
+export interface GridExportedEventArgs {
+    /** `'rows'`, `'csv'`, or the format a writer of `exportSheet()` wrote (`'xlsx'`). */
+    readonly format: 'rows' | 'csv' | 'xlsx' | (string & {});
+    readonly rows: number;
+    /** `'csv'`: the text written. */
+    readonly text?: string;
+}

package/dist/components/datagrid/grid-exporting-event-args.d.ts

@@ -0,0 +1,17 @@
+import type { EventArgs } from '@motifx/core';
+import type { DataGrid } from './DataGrid';
+import type { GridExportOptions } from './grid-export-options';
+/**
+ * An export is about to start (`exportRows`, `exportCsv`, `exportTo`, the toolbar's export button);
+ * change `options`, or `cancel` it. For a format the grid does not write itself (`'xlsx'`), this is
+ * where you write it: `exportDataGrid({ component: e.component, worksheet, selectedRowsOnly: e.selectedRowsOnly })`.
+ */
+export interface GridExportingEventArgs extends EventArgs {
+    /** `'rows'`, `'csv'`, or the format the toolbar or `exportTo` asks for (`'xlsx'`, `'pdf'`…). */
+    readonly format: 'rows' | 'csv' | 'xlsx' | (string & {});
+    /** The grid. */
+    readonly component: DataGrid<any>;
+    /** Only the selected rows ("Export selected rows"). */
+    readonly selectedRowsOnly: boolean;
+    options: GridExportOptions;
+}

package/dist/components/datagrid/grid-filter-builder-closed-event-args.d.ts

@@ -0,0 +1,6 @@
+import type { data } from '@motifx-community/data';
+/** The filter builder closed; `applied` when its value became the filter value. */
+export interface GridFilterBuilderClosedEventArgs {
+    readonly applied: boolean;
+    readonly value: data.FilterExpression | null;
+}

package/dist/components/datagrid/grid-filter-builder-closing-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { EventArgs } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { FilterBuilder } from '../filterbuilder/FilterBuilder';
+/** The filter builder is about to close: with OK (`apply`) its value becomes the filter value. `cancel` keeps it open. */
+export interface GridFilterBuilderClosingEventArgs extends EventArgs {
+    readonly apply: boolean;
+    /** The builder's value. */
+    readonly value: data.FilterExpression | null;
+    readonly builder: FilterBuilder;
+}

package/dist/components/datagrid/grid-filter-builder-opened-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { FilterBuilder } from '../filterbuilder/FilterBuilder';
+import type { MxForm } from '../form/MxForm';
+/** The filter builder opened: the builder and its window. */
+export interface GridFilterBuilderOpenedEventArgs {
+    readonly builder: FilterBuilder;
+    readonly window: MxForm;
+}

package/dist/components/datagrid/grid-filter-builder-opening-event-args.d.ts

@@ -0,0 +1,6 @@
+import type { EventArgs } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+/** The filter builder is about to open on the filter value; `cancel` keeps it closed (open one of your own instead). */
+export interface GridFilterBuilderOpeningEventArgs extends EventArgs {
+    readonly value: data.FilterExpression | null;
+}

package/dist/components/datagrid/grid-filter-builder-options.d.ts

@@ -0,0 +1,7 @@
+import type { ControlProps } from '../../core/control';
+import type { FilterBuilderProps } from '../filterbuilder/filter-builder-props';
+/**
+ * The filter builder the filter panel opens: any prop of `FilterBuilder` but its `value` and
+ * `fields`, which the grid gives (the value, and a field per column with `filterBuilder` on).
+ */
+export type GridFilterBuilderOptions = Omit<FilterBuilderProps, 'value' | 'fields' | keyof ControlProps>;

package/dist/components/datagrid/grid-filter-builder-popup.d.ts

@@ -0,0 +1,22 @@
+import type { Bind } from '@motifx/core';
+/** The modal window the filter builder opens in, the kit's `MxForm`. Read and change it later through `grid.filterBuilderPopup`. */
+export interface GridFilterBuilderPopup {
+    /** Default: the `gridFilterBuilderTitle` text of `uiLocale`. */
+    title?: Bind<string>;
+    /** The title shows in the title bar; off, it still names the window for screen readers. Default `true`. */
+    showTitle?: Bind<boolean>;
+    /** A CSS length; a number is pixels. Default `'40rem'`. */
+    width?: Bind<number | string>;
+    /** A CSS length; a number is pixels. Default: as tall as the builder needs. */
+    height?: Bind<number | string>;
+    /** Resized from its edges. Default `true`. */
+    resizable?: Bind<boolean>;
+    /** Moved by its title bar. Default `true`. */
+    movable?: Bind<boolean>;
+    /** The close button in the title bar (it cancels, like Cancel). Default `true`. */
+    showCloseButton?: Bind<boolean>;
+    /** The maximize button. Default `false`. */
+    showMaximize?: Bind<boolean>;
+    /** Opens maximized, filling the viewport. Default `false`. */
+    fullScreen?: Bind<boolean>;
+}

package/dist/components/datagrid/grid-filter-changed-event-args.d.ts

@@ -0,0 +1,12 @@
+import type { data } from '@motifx-community/data';
+import type { GridFilters } from './grid-filters';
+/** The filters applied. */
+export interface GridFilterChangedEventArgs {
+    readonly filters: GridFilters;
+    /** The whole filter of the rows, as the data layer has it. */
+    readonly filter: data.FilterExpression | null;
+    /** The filter value (what the filter panel shows), as chosen. */
+    readonly filterValue: data.FilterExpression | null;
+    /** Whether the filter value applies (the filter panel's check box). */
+    readonly filterEnabled: boolean;
+}

package/dist/components/datagrid/grid-filter-changing-event-args.d.ts

@@ -0,0 +1,15 @@
+import type { EventArgs } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { GridFilters } from './grid-filters';
+/**
+ * The filters (filter row, header filters, the filter value of the builder, the panel's check box)
+ * are about to apply; `cancel` puts the ones before back.
+ */
+export interface GridFilterChangingEventArgs extends EventArgs {
+    readonly filters: GridFilters;
+    readonly previous: GridFilters;
+    readonly filterValue: data.FilterExpression | null;
+    readonly previousFilterValue: data.FilterExpression | null;
+    readonly filterEnabled: boolean;
+    readonly previousFilterEnabled: boolean;
+}

package/dist/components/datagrid/grid-filter-operator.d.ts

@@ -0,0 +1,2 @@
+/** A condition of the filter row; the names are the data layer's operators. */
+export type GridFilterOperator = 'contains' | 'startswith' | 'endswith' | '=' | '<>' | '<' | '<=' | '>' | '>=' | 'between' | 'isblank' | 'isnotblank';

package/dist/components/datagrid/grid-filter-panel-text-info.d.ts

@@ -0,0 +1,6 @@
+import type { data } from '@motifx-community/data';
+/** What `filterPanelText` gets: the text the panel would show and the filter value it reads. */
+export interface GridFilterPanelTextInfo {
+    text: string;
+    filterValue: data.FilterExpression | null;
+}

package/dist/components/datagrid/grid-filter-value.d.ts

@@ -0,0 +1,9 @@
+/** One entry of a header filter's value list. */
+export interface GridFilterValue {
+    /** `null` stands for empty values. */
+    value: unknown;
+    /** Display text; default: the value formatted like the column's cells. */
+    text?: string;
+    /** Rows with this value. */
+    count?: number;
+}

package/dist/components/datagrid/grid-filters.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnFilter } from './column-filter';
+/** The grid's filters by field. Read and assign them through `grid.filters`. */
+export type GridFilters = Record<string, ColumnFilter>;

package/dist/components/datagrid/grid-focused-cell-changed-event-args.d.ts

@@ -0,0 +1,6 @@
+/** The active cell moved. */
+export interface GridFocusedCellChangedEventArgs<T> {
+    readonly rowIndex: number;
+    readonly field: string;
+    readonly row: T | undefined;
+}

package/dist/components/datagrid/grid-focused-cell-changing-event-args.d.ts

@@ -0,0 +1,13 @@
+import type { EventArgs } from '@motifx/core';
+/**
+ * The active cell is about to move (keys, a click, code). Row indexes count new rows; -1 is the header,
+ * -2 the filter row. `cancel` keeps it where it is.
+ */
+export interface GridFocusedCellChangingEventArgs<T> extends EventArgs {
+    readonly rowIndex: number;
+    readonly field: string;
+    readonly previousRowIndex: number;
+    readonly previousField: string;
+    /** The row it moves to; `undefined` on the header, a group row or a row that loads. */
+    readonly row: T | undefined;
+}

package/dist/components/datagrid/grid-focused-row-changed-event-args.d.ts

@@ -0,0 +1,7 @@
+/** The active row changed. */
+export interface GridFocusedRowChangedEventArgs<T> {
+    readonly rowIndex: number;
+    readonly row: T | undefined;
+    /** The row's key; `undefined` for a new row, a group row or the header. */
+    readonly key: unknown;
+}

package/dist/components/datagrid/grid-focused-row-changing-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { EventArgs } from '@motifx/core';
+/** The active row is about to change; `cancel` keeps it (and the active cell). */
+export interface GridFocusedRowChangingEventArgs<T> extends EventArgs {
+    readonly rowIndex: number;
+    readonly previousRowIndex: number;
+    readonly row: T | undefined;
+}

package/dist/components/datagrid/grid-group-dropping-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+/** A header or a chip is dropped to change the grouping; `cancel` leaves the grouping as it is. */
+export interface GridGroupDroppingEventArgs extends EventArgs {
+    readonly field: string;
+    /** What was dragged: a column's header, or a chip of the group panel. */
+    readonly from: 'header' | 'chip';
+    /** Where it was dropped: on the group panel, or back on the headers. */
+    readonly to: 'panel' | 'headers';
+    /** The place it lands: among the chips on the panel, among the columns of its zone on the headers. */
+    readonly index: number;
+}

package/dist/components/datagrid/grid-group-summary-item.d.ts

@@ -0,0 +1,12 @@
+import type { Bind } from '@motifx/core';
+import type { GridSummaryItem } from './grid-summary-item';
+/**
+ * One item of the group summary: a value of each group's rows, in its group row ("City: Ankara (12)
+ * · Sum of Amount: 1,234"), under its column in the group row, or in a row after the group's rows.
+ */
+export interface GridGroupSummaryItem extends GridSummaryItem {
+    /** In a footer row after each group's rows, under `showInColumn` (else `column`). Default `false`. */
+    showInGroupFooter?: Bind<boolean | undefined>;
+    /** Under `showInColumn` (else `column`) in the group row instead of after its text; not under the first column, which holds the text. Default `false`. */
+    alignByColumn?: Bind<boolean | undefined>;
+}

package/dist/components/datagrid/grid-grouping-changed-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { data } from '@motifx-community/data';
+/** The grouping changed (by the user or from code). */
+export interface GridGroupingChangedEventArgs {
+    readonly group: readonly data.GroupItem[];
+    readonly previous: readonly data.GroupItem[];
+    readonly byUser: boolean;
+}

package/dist/components/datagrid/grid-grouping-changing-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { EventArgs } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+/** The grouping is about to change (by the user or from code); `cancel` keeps it as it is. */
+export interface GridGroupingChangingEventArgs extends EventArgs {
+    /** The grouped columns it changes to, in order. */
+    readonly group: readonly data.GroupItem[];
+    readonly previous: readonly data.GroupItem[];
+    /** The user changed it (the group panel, the column menu, a header, a chip); `false` from code. */
+    readonly byUser: boolean;
+}

package/dist/components/datagrid/grid-header-filter-interval.d.ts

@@ -0,0 +1,7 @@
+import type { GridDateInterval } from './grid-date-interval';
+/**
+ * How a column's header filter groups its values: for a number column the size of each range
+ * ("0 – 100", "100 – 200"; several sizes make a tree, the largest first), for a date column the
+ * deepest part of its year → month → day … tree. `null` lists the values one by one.
+ */
+export type GridHeaderFilterInterval = number | readonly number[] | GridDateInterval | null;

package/dist/components/datagrid/grid-header-filter-items-request.d.ts

@@ -0,0 +1,12 @@
+import type { data } from '@motifx-community/data';
+import type { GridColumn } from './grid-column';
+import type { GridFilterValue } from './grid-filter-value';
+/** What a column's `headerFilterItems` function is asked with. */
+export interface GridHeaderFilterItemsRequest<T> {
+    column: GridColumn<T>;
+    /** The other filters of the grid (and the source's own). */
+    filter: data.FilterExpression | null;
+    signal: AbortSignal;
+    /** The values the header filter would list without the function, with their counts, to add to or change. */
+    values(): Promise<GridFilterValue[]>;
+}

package/dist/components/datagrid/grid-header-filter-items.d.ts

@@ -0,0 +1,7 @@
+import type { GridFilterValue } from './grid-filter-value';
+import type { GridHeaderFilterItemsRequest } from './grid-header-filter-items-request';
+/**
+ * The entries of a column's header filter instead of its values: `{ text, value }` items, where a
+ * value may be a filter expression (`data.where('amount', '<', 100)`); or a function that gives them.
+ */
+export type GridHeaderFilterItems<T> = readonly GridFilterValue[] | ((request: GridHeaderFilterItemsRequest<T>) => readonly GridFilterValue[] | Promise<readonly GridFilterValue[]>);

package/dist/components/datagrid/grid-init-new-row-event-args.d.ts

@@ -0,0 +1,9 @@
+import type { EventArgs } from '@motifx/core';
+/**
+ * A new row is about to open. `data` is what it starts with (`newRow.create()`), `values` what counts
+ * as entered (the values given to `addRow`); change either. `cancel` opens no row.
+ */
+export interface GridInitNewRowEventArgs<T> extends EventArgs {
+    data: Partial<T>;
+    values: Partial<T>;
+}

package/dist/components/datagrid/grid-key-handling-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+/**
+ * A key went down in the grid (a cell, an editor, the filter row, a group chip) and the grid is about
+ * to handle it. `cancel` stops the grid's own handling: do your own with `event`.
+ */
+export interface GridKeyHandlingEventArgs extends EventArgs {
+    readonly event: KeyboardEvent;
+    /** The active row (-1 the header, -2 the filter row). */
+    readonly rowIndex: number;
+    readonly field: string;
+}

package/dist/components/datagrid/grid-layout-changing-event-args.d.ts

@@ -0,0 +1,7 @@
+import type { EventArgs } from '@motifx/core';
+import type { GridLayout } from './grid-layout';
+/** The user changed the layout (resize, move, hide, pin, sort, reset); `cancel` puts the one before back. */
+export interface GridLayoutChangingEventArgs extends EventArgs {
+    readonly layout: GridLayout;
+    readonly previous: GridLayout;
+}

package/dist/components/datagrid/grid-layout.d.ts

@@ -0,0 +1,16 @@
+import type { data } from '@motifx-community/data';
+import type { BandLayout } from './band-layout';
+import type { ColumnLayout } from './column-layout';
+/**
+ * Column order, widths, visibility, sticky sides, sort order and grouping. Read it from `grid.layout`,
+ * store it wherever you like, and give it back through the `layout` prop or `grid.layout = …`.
+ */
+export interface GridLayout {
+    /** Every column, in display order. */
+    columns: ColumnLayout[];
+    /** Bands that are hidden or pinned; their place comes from their columns'. Left out: as the bands say. */
+    bands?: BandLayout[];
+    sort: data.SortItem[];
+    /** The grouped columns, in order, with the order of their groups. Left out: as the columns say (`groupIndex`). */
+    group?: data.GroupItem[];
+}

package/dist/components/datagrid/grid-load-panel.d.ts

@@ -0,0 +1,11 @@
+/** The panel over the rows while an export runs: what it says, how far it got, and a button that stops it. */
+export interface GridLoadPanel {
+    /** Default `true` for `exportDataGrid`, `false` for `exportCsv` and `exportRows`. */
+    enabled?: boolean;
+    /** Default: the `gridExporting` text of `uiLocale`. */
+    text?: string;
+    /** "1,000 of 25,000 rows" under the text, with a progress bar. Default `true`. */
+    showProgress?: boolean;
+    /** A button that stops the export (its promise rejects with an `AbortError`). Default `true`. */
+    cancelButton?: boolean;
+}

package/dist/components/datagrid/grid-lookup.d.ts

@@ -0,0 +1,47 @@
+import type { Bind } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+/**
+ * Where a lookup column's texts come from: the cell keeps a key (a customer id), the grid shows the
+ * text of its item (the customer's name). The items may live on another service than the rows, over
+ * another adapter; only the keys on the screen are asked for, several at once.
+ *
+ * @example
+ * { field: 'customerId', title: 'Customer', lookup: { dataSource: customers, valueField: 'id', textField: 'name' } }
+ */
+export interface GridLookup<T = any> {
+    /** The items: a data source (searched and resolved on its service) or an array in memory. */
+    dataSource: Bind<data.DataSource<any, any> | readonly unknown[]>;
+    /** Field of an item that matches the cell value. Default: the data source's key; for an array of plain values, the value itself. */
+    valueField?: string;
+    /** The text shown: a field of the item or a function of it. Default: the value. */
+    textField?: string | ((item: any) => string);
+    /** Fields the editor and the text search look in. Default: `textField` when it is a field. */
+    searchFields?: readonly string[];
+    /**
+     * Narrows the items for a row (cascading lists: the cities of the row's state, `context.getValue('state')`,
+     * which is the value entered when there is one). `null` row: every item (filter lists).
+     */
+    filter?: (row: T | null, context: data.RowCheckContext<T>) => data.FilterExpression | null | undefined;
+    /** A clear button in the editor, so the cell can be emptied. Default `false`. */
+    allowClearing?: Bind<boolean>;
+    /** `'batch'` (default): the unknown keys on screen in one request (`valueField in [...]`, at most `batchSize` keys each). `'byKey'`: one request per key, for services that only fetch one item by key. */
+    resolve?: 'batch' | 'byKey';
+    /** Keys per request in `'batch'` mode. Default 100. */
+    batchSize?: number;
+    /** Rows in memory sorted by the key (default, as the service sorts) or by the text shown (every key of the rows is resolved first). */
+    sortBy?: Bind<'key' | 'text'>;
+    /** The editor: `'dropdown'` (default; with search), `'combobox'` or `'lookup'` (the kit's `Lookup`, a table-like list). */
+    editor?: 'dropdown' | 'combobox' | 'lookup';
+    /** Props given to the editor (e.g. the `Lookup`'s `columns`). */
+    editorOptions?: Record<string, unknown>;
+    /** The most items whose text holds the search panel's text that the search turns into keys. Default 100. */
+    searchLimit?: number;
+    /** Items the editor's list loads per request while it scrolls (a data source). Default 50. */
+    pageSize?: number;
+    /** The most items whose text holds the header filter's search text that it turns into keys. Default 1000. */
+    filterSearchLimit?: number;
+    /** `'byKey'`: requests at the same time. Default 6. */
+    parallelRequests?: number;
+    /** Items a pasted text is looked for in. Default 50. */
+    pasteSearchLimit?: number;
+}