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

package/dist/components/datagrid/band-cell-context.d.ts

@@ -0,0 +1,7 @@
+import type { GridBand } from './grid-band';
+/** What a band's `headerCell` content gets: read its fields inside getters. */
+export interface BandCellContext<T> {
+    readonly band: GridBand<T>;
+    /** The title, as `title` gives it now. */
+    readonly title: string;
+}

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

@@ -0,0 +1,7 @@
+import type { StickySide } from './sticky-side';
+/** Saved state of one band in a `GridLayout`; its place comes from its columns'. */
+export interface BandLayout {
+    name: string;
+    hidden: boolean;
+    sticky: StickySide | null;
+}

package/dist/components/datagrid/built-in-action.d.ts

@@ -0,0 +1,3 @@
+import type { GridBuiltInActions } from './grid-built-in-actions';
+/** The name of an action the grid has ready. */
+export type BuiltInAction = keyof GridBuiltInActions<unknown>;

package/dist/components/datagrid/cell-context.d.ts

@@ -0,0 +1,14 @@
+import type { GridColumn } from './grid-column';
+/**
+ * What a custom cell receives. The grid reuses the cell for other rows while it scrolls, so read
+ * `row` and `value` inside getters (`{() => ctx.row?.name}`).
+ */
+export interface CellContext<T> {
+    /** The row shown in this cell right now; `undefined` while it is loading. */
+    readonly row: T | undefined;
+    /** The value to show: the unsaved edit when there is one, else the row's value. */
+    readonly value: unknown;
+    /** Index of the row in the grid (new rows included). */
+    readonly index: number;
+    readonly column: GridColumn<T>;
+}

package/dist/components/datagrid/column-features.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Column features the user can use. Turn them on or off for every column through the grid's
+ * `settings`, and for one column with the field of the same name on its definition; the column's
+ * value wins (`settings: { resizable: false }` and `{ field: 'note', resizable: true }` lets only
+ * that column be resized).
+ */
+export interface ColumnFeatures {
+    /** Edit the cells in place: typing, Enter, F2 or a double-click opens the cell's editor. Default `false`. */
+    editable: boolean;
+    /**
+     * Fill the cells of a new row (until it is saved). Default `true`. A column that sets its own
+     * `editable` and not `creatable` uses the same value for new rows; `editable: false, creatable: true`
+     * is a column entered only once, when the row is created.
+     */
+    creatable: boolean;
+    /** Sort by clicking the header, with Enter on it, or from the column menu. Default `true`. */
+    sortable: boolean;
+    /** Resize: drag the header edge, double-click it to fit, or "Width" in the column menu. Default `true`. */
+    resizable: boolean;
+    /** Move: drag the header, or "Move" in the column menu. A column that cannot move keeps its place. Default `true`. */
+    movable: boolean;
+    /** Hide from the column menu and the column list. Default `true`. */
+    hideable: boolean;
+    /** Pin to the start or end edge, or unpin, from the column menu. Default `true`. */
+    pinnable: boolean;
+    /** The column menu: its button in the header, and Alt+ArrowDown on the header. Default `true`. */
+    menu: boolean;
+    /** A cell in the filter row: a condition and a value box by the column type. The row shows while a visible column has one. Default `false`. */
+    filterRow: boolean;
+    /** The header filter: a button in the header (and an entry in the column menu) that opens the column's values to choose from. Default `false`. */
+    headerFilter: boolean;
+    /** The column is a field of the filter builder (and its conditions read with its title in the filter panel). Default `true`. */
+    filterBuilder: boolean;
+    /** The column's cells go into what Ctrl+C copies. Default `true`. */
+    copyable: boolean;
+    /** The column's cells can be selected in cell ranges (`cellSelection`); off, a range leaves them out and a press there draws none. Default `true`. */
+    cellSelectable: boolean;
+    /** The column goes into `exportCsv()` and `exportRows()`. Default `true`. */
+    exportable: boolean;
+    /**
+     * A lookup column's filter row and header filter list only the keys present in the rows that the
+     * other columns' filters leave (the cities of the chosen state). Default `true`.
+     */
+    syncLookupFilterValues: boolean;
+    /**
+     * The search panel looks in this column. Default `true`; a column that turns its own filters off
+     * (`filterRow: false` and no `headerFilter: true`, or the other way round) is left out unless it
+     * sets `searchable` itself.
+     */
+    searchable: boolean;
+    /**
+     * Group by the column: drag its header to the group panel, or "Group by this column" in its menu.
+     * Grouping set in code (`groupIndex`, `grid.group`) works either way. Default `true`.
+     */
+    groupable: boolean;
+    /** A grouped column still shows among the other columns. Default `false`. */
+    showWhenGrouped: boolean;
+    /** The user can open and close the groups of this column; off, only code can (`expandAll()`, `collapseGroup()`…). Default `true`. */
+    allowCollapsing: boolean;
+    /** Group rows show how many rows the group holds, "(12)". Default `true`. */
+    groupCount: boolean;
+    /**
+     * "Group by this column", "Ungroup" and "Ungroup all" in the column menu. Left unset (grid and
+     * column), they show while the group panel lets headers be dragged, as the keyboard's way to do
+     * the same.
+     */
+    groupMenu: boolean;
+}

package/dist/components/datagrid/column-filter.d.ts

@@ -0,0 +1,20 @@
+import type { GridFilterOperator } from './grid-filter-operator';
+/**
+ * The filter of one column: the condition of the filter row (`op`, `value`, and `value2` for
+ * `between`) and the values chosen in the header filter (any of them). Both apply together.
+ */
+export interface ColumnFilter {
+    /** Default: by the column type (`contains` for text, `=` otherwise). */
+    op?: GridFilterOperator;
+    value?: unknown;
+    /** The upper end of `between`. */
+    value2?: unknown;
+    /**
+     * Values of the header filter; `null` stands for empty values. A value can also be the start of an
+     * interval (`headerFilterInterval`), a date part (`2024`, `'2024/3'`) or an item's own value
+     * (`headerFilterItems`, a filter expression too).
+     */
+    values?: readonly unknown[];
+    /** `'exclude'`: the rows with `values` are left out instead of kept. Default `'include'`. */
+    filterType?: 'include' | 'exclude';
+}

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

@@ -0,0 +1,10 @@
+import type { StickySide } from './sticky-side';
+/** Saved state of one column in a `GridLayout`. */
+export interface ColumnLayout {
+    field: string;
+    width: number;
+    /** Free-space share; 0 once the user has resized the column. */
+    flex: number;
+    hidden: boolean;
+    sticky: StickySide | null;
+}

package/dist/components/datagrid/column-option-name.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnFeatures } from './column-features';
+import type { GridColumn } from './grid-column';
+/**
+ * A column option `grid.columnOption(field, name)` reads and writes: the layout's, the sort order,
+ * the grouping, the header filter's values, a feature switch, or any field of the definition.
+ */
+export type ColumnOptionName = 'width' | 'visible' | 'hidden' | 'flex' | 'sticky' | 'visibleIndex' | 'sortOrder' | 'sortIndex' | 'groupIndex' | 'filterValues' | 'filterType' | keyof ColumnFeatures | keyof GridColumn;

package/dist/components/datagrid/column-resize-mode.d.ts

@@ -0,0 +1,2 @@
+/** How a column's edge is dragged: the column alone, or against the next column. */
+export type ColumnResizeMode = 'widget' | 'nextColumn';

package/dist/components/datagrid/column-type.d.ts

@@ -0,0 +1,2 @@
+/** How a column's values are compared, formatted and edited. */
+export type ColumnType = 'text' | 'number' | 'date' | 'boolean' | 'list';

package/dist/components/datagrid/data-grid-props.d.ts

@@ -0,0 +1,353 @@
+import type { Bind } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { ControlProps } from '../../core/control';
+import type { UiStrings } from '../../core/ui-strings';
+import type { GridActionItem } from './grid-action-item';
+import type { GridActionRanEventArgs } from './grid-action-ran-event-args';
+import type { GridActionRunningEventArgs } from './grid-action-running-event-args';
+import type { GridCellClickEventArgs } from './grid-cell-click-event-args';
+import type { GridCellPreparedEventArgs } from './grid-cell-prepared-event-args';
+import type { GridContentReadyEventArgs } from './grid-content-ready-event-args';
+import type { GridContextMenuPreparingEventArgs } from './grid-context-menu-preparing-event-args';
+import type { GridCopyingEventArgs } from './grid-copying-event-args';
+import type { GridDataErrorEventArgs } from './grid-data-error-event-args';
+import type { GridEditCanceledEventArgs } from './grid-edit-canceled-event-args';
+import type { GridEditCancelingEventArgs } from './grid-edit-canceling-event-args';
+import type { GridEditingStartEventArgs } from './grid-editing-start-event-args';
+import type { GridExportedEventArgs } from './grid-exported-event-args';
+import type { GridExportSettings } from './grid-export-settings';
+import type { GridExportingEventArgs } from './grid-exporting-event-args';
+import type { GridFilterChangedEventArgs } from './grid-filter-changed-event-args';
+import type { GridFilterChangingEventArgs } from './grid-filter-changing-event-args';
+import type { GridFocusedCellChangedEventArgs } from './grid-focused-cell-changed-event-args';
+import type { GridFocusedCellChangingEventArgs } from './grid-focused-cell-changing-event-args';
+import type { GridFocusedRowChangedEventArgs } from './grid-focused-row-changed-event-args';
+import type { GridFocusedRowChangingEventArgs } from './grid-focused-row-changing-event-args';
+import type { GridInitNewRowEventArgs } from './grid-init-new-row-event-args';
+import type { GridKeyHandlingEventArgs } from './grid-key-handling-event-args';
+import type { GridLayoutChangingEventArgs } from './grid-layout-changing-event-args';
+import type { GridOptionChangedEventArgs } from './grid-option-changed-event-args';
+import type { GridPageChangedEventArgs } from './grid-page-changed-event-args';
+import type { GridPageChangingEventArgs } from './grid-page-changing-event-args';
+import type { GridPageSizeChangedEventArgs } from './grid-page-size-changed-event-args';
+import type { GridPageSizeChangingEventArgs } from './grid-page-size-changing-event-args';
+import type { GridPastingEventArgs } from './grid-pasting-event-args';
+import type { GridRowClickEventArgs } from './grid-row-click-event-args';
+import type { GridRowInsertedEventArgs } from './grid-row-inserted-event-args';
+import type { GridRowInsertingEventArgs } from './grid-row-inserting-event-args';
+import type { GridRowPreparedEventArgs } from './grid-row-prepared-event-args';
+import type { GridRowRemovedEventArgs } from './grid-row-removed-event-args';
+import type { GridRowRemovingEventArgs } from './grid-row-removing-event-args';
+import type { GridRowUpdatedEventArgs } from './grid-row-updated-event-args';
+import type { GridRowUpdatingEventArgs } from './grid-row-updating-event-args';
+import type { GridSavedEventArgs } from './grid-saved-event-args';
+import type { GridSavingEventArgs } from './grid-saving-event-args';
+import type { GridSearchTextChangingEventArgs } from './grid-search-text-changing-event-args';
+import type { GridSelectionChangingEventArgs } from './grid-selection-changing-event-args';
+import type { GridSortChangedEventArgs } from './grid-sort-changed-event-args';
+import type { GridSortChangingEventArgs } from './grid-sort-changing-event-args';
+import type { GridSummary } from './grid-summary';
+import type { GridSummaryChangedEventArgs } from './grid-summary-changed-event-args';
+import type { GridToolbarPreparingEventArgs } from './grid-toolbar-preparing-event-args';
+import type { LayoutStorage } from './layout-storage';
+import type { GridEditForm } from './grid-edit-form';
+import type { GridEditPopup } from './grid-edit-popup';
+import type { GridMasterDetail } from './grid-master-detail';
+import type { GridEditorPreparedEventArgs } from './grid-editor-prepared-event-args';
+import type { GridEditorPreparingEventArgs } from './grid-editor-preparing-event-args';
+import type { GridRowValidatingEventArgs } from './grid-row-validating-event-args';
+import type { GridFilters } from './grid-filters';
+import type { GridFilterBuilderClosedEventArgs } from './grid-filter-builder-closed-event-args';
+import type { GridFilterBuilderClosingEventArgs } from './grid-filter-builder-closing-event-args';
+import type { GridFilterBuilderOpenedEventArgs } from './grid-filter-builder-opened-event-args';
+import type { GridFilterBuilderOpeningEventArgs } from './grid-filter-builder-opening-event-args';
+import type { GridFilterBuilderOptions } from './grid-filter-builder-options';
+import type { GridFilterBuilderPopup } from './grid-filter-builder-popup';
+import type { GridFilterPanelTextInfo } from './grid-filter-panel-text-info';
+import type { GridGroupDroppingEventArgs } from './grid-group-dropping-event-args';
+import type { GridGroupingChangedEventArgs } from './grid-grouping-changed-event-args';
+import type { GridGroupingChangingEventArgs } from './grid-grouping-changing-event-args';
+import type { GridLayout } from './grid-layout';
+import type { GridAdaptiveDetail } from './grid-adaptive-detail';
+import type { GridAdaptiveDetailRowPreparingEventArgs } from './grid-adaptive-detail-row-preparing-event-args';
+import type { GridAdaptiveRowExpandedEventArgs } from './grid-adaptive-row-expanded-event-args';
+import type { GridAdaptiveRowExpandingEventArgs } from './grid-adaptive-row-expanding-event-args';
+import type { GridColumnItem } from './grid-column-item';
+import type { GroupCellContext } from './group-cell-context';
+import type { GridRowDragging } from './grid-row-dragging';
+import type { GridRowExpandedEventArgs } from './grid-row-expanded-event-args';
+import type { GridRowExpandingEventArgs } from './grid-row-expanding-event-args';
+import type { GridMode } from './grid-mode';
+import type { GridMoreRowsLoadedEventArgs } from './grid-more-rows-loaded-event-args';
+import type { GridMoreRowsLoadingEventArgs } from './grid-more-rows-loading-event-args';
+import type { GridSettingsProps } from './grid-settings-props';
+import type { GridSearchTextChangedEventArgs } from './grid-search-text-changed-event-args';
+import type { GridSelectionChangedEventArgs } from './grid-selection-changed-event-args';
+import type { GridCellRange } from './grid-cell-range';
+import type { GridCellSelectionChangedEventArgs } from './grid-cell-selection-changed-event-args';
+import type { GridCellSelectionChangingEventArgs } from './grid-cell-selection-changing-event-args';
+import type { GridToolbar } from './grid-toolbar';
+import type { GridValuesRequest } from './grid-values-request';
+import type { GridValuesResult } from './grid-values-result';
+import type { NewRowOptions } from './new-row-options';
+import type { RowState } from './row-state';
+/** Props of `DataGrid`. Every one but `columns`, `rowKey`, `sort`, `layout`, `layoutKey`, `filters`, `toolbar`, `export`, `form`, `popup`, `filterBuilder`, `filterBuilderPopup`, `masterDetail`, `adaptiveDetail` and `rowDragging` (whose fields are) and the callbacks is a value or a function that is followed. */
+export interface DataGridProps<T> extends ControlProps {
+    /**
+     * Column definitions, in their initial order, and bands over them (`{ title, columns: [...] }`).
+     * Columns come and go later with `addColumn` and `deleteColumn`.
+     */
+    columns: GridColumnItem<T>[];
+    /**
+     * Rows in memory, plain or reactive: the grid reads them as they are and gives back the same
+     * objects. It puts them in a `DataSource` over an `ArrayAdapter` itself; a new array (or a function
+     * that returns one) loads again, and after a change in place (`push`, `splice`, a field) call
+     * `grid.refresh()` or `grid.repaintRows(keys)`. Saved edits, new rows and deletions go into the array.
+     */
+    rows?: Bind<T[]>;
+    /** Rows from the data layer, any adapter. `'blocks'` loads where the virtual list looks, `'page'` shows pages. Wins over `rows`. */
+    dataSource?: Bind<data.DataSource<T, any> | null>;
+    /** The row's identity for `rows`: a field name or a function. A `dataSource` uses its adapter's key. */
+    rowKey?: string | ((row: T) => unknown);
+    /**
+     * `'virtual'` (default): one long list, loaded and drawn where the view is. `'paged'`: pages with a
+     * pager. `'infinite'`: the rows show part by part (`pageSize` each), the next part loading as the
+     * view nears the end; no total is needed (a source with `count: false` finds the end from a short
+     * part). A `dataSource` that loads by `'page'` is always paged.
+     */
+    mode?: Bind<GridMode>;
+    /**
+     * Rows per page in paged mode (0: every row on one page), and of a part in infinite mode, for rows in memory. A `dataSource` that
+     * loads pages or blocks uses its own `pageSize`. The user can change it from the pager's page sizes
+     * (`settings.pageSizeSelector`). Default 100.
+     */
+    pageSize?: Bind<number>;
+    /** Row height in pixels. Default: read from the grid's CSS, which follows the density. */
+    rowHeight?: Bind<number>;
+    /** Initial sort order. */
+    sort?: data.SortItem[];
+    /** Initial layout (overrides the columns' own width, order, hidden and sticky settings). */
+    layout?: GridLayout;
+    /** Called after the user changes the layout (resize, move, hide, sticky, sort). */
+    onLayoutChange?: (layout: GridLayout) => void;
+    /** The user is about to change the layout; `e.cancel` puts the one before back. */
+    onLayoutChanging?: (e: GridLayoutChangingEventArgs) => void;
+    /**
+     * A name to keep the layout, the filters and the search text under in the browser's `localStorage`:
+     * they come back when a grid with the same name is made again, over `layout`, `sort`, `filters` and
+     * `searchText`.
+     */
+    layoutKey?: string;
+    /** Where `layoutKey` keeps the layout: `sessionStorage`, or any object with `getItem`, `setItem` and `removeItem`. Default `localStorage`. */
+    layoutStorage?: LayoutStorage;
+    /** Accessible name of the grid. The same as `text`. */
+    label?: Bind<string>;
+    /** Texts for this grid only, over `uiLocale.strings`. */
+    texts?: Bind<Partial<UiStrings>>;
+    /** Locale of number and date formatting and of text sorting. Default: the page's language. */
+    locale?: Bind<string>;
+    /** Features turned on or off; see `GridSettings`. Read and change them later through `grid.settings`. */
+    settings?: GridSettingsProps;
+    /** When changes are sent: on leaving each row and waiting for it, without waiting, or all at once. Default `'wait'`. */
+    saveMode?: Bind<data.SaveMode>;
+    /** Where new rows open and their initial values. */
+    newRow?: NewRowOptions<T>;
+    /** The edit form of `settings.editMode` `'form'` and `'popup'`: its items, columns and labels. Read and change it later through `grid.form`. */
+    form?: GridEditForm;
+    /** The window of `settings.editMode: 'popup'`: title, size, buttons. Read and change it later through `grid.popup`. */
+    popup?: GridEditPopup;
+    /** Details under the rows: an expand column, and what `template` makes for each row in a row across the grid. Read and change it later through `grid.masterDetail`. */
+    masterDetail?: GridMasterDetail<T>;
+    /** The adaptive detail of a row, while columns hide to fit the width (`settings.columnHidingEnabled`, a column's `hidingPriority`). Read and change it later through `grid.adaptiveDetail`. */
+    adaptiveDetail?: GridAdaptiveDetail;
+    /**
+     * Rows moved by dragging (a column of drag icons, or the whole row) and with the keyboard: within
+     * the grid, onto a row, or to another grid of the same `group`. The handlers move the data. Read and
+     * change it later through `grid.rowDragging`.
+     */
+    rowDragging?: GridRowDragging<T>;
+    /**
+     * Checks a whole row before it is saved: a message per field, or one message for the row. `row` is
+     * the row itself; `context.values` holds the values entered and not saved yet, `context.getValue(field)`
+     * the value a field is saved with (the entered one, else the row's), `changed` the fields entered.
+     */
+    validateRow?: (row: T, context: data.RowCheckContext<T> & {
+        readonly changed: readonly string[];
+    }) => Readonly<Record<string, string | null | undefined>> | string | null | undefined | void;
+    /**
+     * The buttons of each row, in order of importance: those that do not fit go into the row's
+     * "more" menu. A function of the row and its state is asked again when the row's state changes
+     * (edited, saved, selected) and on `refreshActions()`. Strings name the grid's own actions (`'edit'`, `'remove'`, `'restore'`,
+     * `'save'`, `'cancel'`).
+     */
+    actions?: readonly GridActionItem<T>[] | ((row: T, state: RowState) => readonly GridActionItem<T>[]);
+    /** An action is about to run (in a row, a bar, a row's menu or from code): `e.cancel` keeps it from running. */
+    onActionRunning?: (e: GridActionRunningEventArgs<T>) => void;
+    /** An action ran: on how many rows it worked or failed, and whether it was stopped. */
+    onActionRan?: (e: GridActionRanEventArgs<T>) => void;
+    /** Keys of the selected rows; a function is followed. The user's changes come through `onSelectionChanged`. */
+    selectedKeys?: Bind<readonly unknown[]>;
+    /** The selection is about to change; `e.cancel` keeps it. */
+    onSelectionChanging?: (e: GridSelectionChangingEventArgs) => void;
+    onSelectionChanged?: (e: GridSelectionChangedEventArgs) => void;
+    /** The cell ranges (`settings.cellSelection`); a function is followed. The user's changes come through `onCellSelectionChanged`. */
+    cellRanges?: Bind<readonly GridCellRange[]>;
+    /** The cell ranges are about to change; `e.cancel` keeps them. */
+    onCellSelectionChanging?: (e: GridCellSelectionChangingEventArgs) => void;
+    onCellSelectionChanged?: (e: GridCellSelectionChangedEventArgs) => void;
+    /** Before an editor of a cell or of an edit form field is made: change its props (`e.options`), or `e.cancel` it. */
+    onEditorPreparing?: (e: GridEditorPreparingEventArgs<T>) => void;
+    /** An editor was made, in a cell or in the edit form. */
+    onEditorPrepared?: (e: GridEditorPreparedEventArgs<T>) => void;
+    /** A row is checked before it is saved, after its cells: add or remove messages, or `e.isValid = false`. */
+    onRowValidating?: (e: GridRowValidatingEventArgs<T>) => void;
+    /**
+     * The search panel's text: the rows that hold it in a searchable column. A function is followed;
+     * what the user types comes through `onSearchTextChanged`.
+     */
+    searchText?: Bind<string>;
+    /** The search text is about to change; `e.cancel` keeps the one before. */
+    onSearchTextChanging?: (e: GridSearchTextChangingEventArgs) => void;
+    /** The search text changed (typed, or set from code). */
+    onSearchTextChanged?: (e: GridSearchTextChangedEventArgs) => void;
+    /**
+     * Values of the rows under the filter and the search: a row of totals under the rows
+     * (`totalItems`) and values of each group in its row or footer (`groupItems`), also custom ones.
+     * Read and change it later through `grid.summary`.
+     */
+    summary?: Bind<GridSummary<T>>;
+    /** The summary values were worked out again (new data, or unsaved changes with `recalculateWhileEditing`). */
+    onSummaryChanged?: (e: GridSummaryChangedEventArgs) => void;
+    /** Content of your own in every group row whose column has no `groupCell`, made once per pooled group row. */
+    groupCell?: (ctx: GroupCellContext<T>) => unknown;
+    /** The grouping is about to change (user or code): `e.group`, `e.previous`, `e.byUser`; `e.cancel` keeps it. */
+    onGroupingChanging?: (e: GridGroupingChangingEventArgs) => void;
+    /** The grouping changed. */
+    onGroupingChanged?: (e: GridGroupingChangedEventArgs) => void;
+    /** A header or a chip is dropped: `e.field`, `e.from`, `e.to`, `e.index`; `e.cancel` cancels the drop. */
+    onGroupDropping?: (e: GridGroupDroppingEventArgs) => void;
+    /**
+     * A group or a row's details are about to open: `e.kind` says which (`'group'`, `'detail'`), `e.key`
+     * is the group's key (the values from the top level down) or the row's; `e.cancel` keeps it closed.
+     */
+    onRowExpanding?: (e: GridRowExpandingEventArgs) => void;
+    /** A group or a row's details opened. */
+    onRowExpanded?: (e: GridRowExpandedEventArgs) => void;
+    /** A group or a row's details are about to close; `e.cancel` keeps it open. */
+    onRowCollapsing?: (e: GridRowExpandingEventArgs) => void;
+    /** A group or a row's details closed. */
+    onRowCollapsed?: (e: GridRowExpandedEventArgs) => void;
+    /** A row's adaptive detail is about to lay out its form: change `e.formOptions`. */
+    onAdaptiveDetailRowPreparing?: (e: GridAdaptiveDetailRowPreparingEventArgs<T>) => void;
+    /** A row's adaptive detail is about to open; `e.cancel` keeps it closed. */
+    onAdaptiveDetailRowExpanding?: (e: GridAdaptiveRowExpandingEventArgs<T>) => void;
+    onAdaptiveDetailRowExpanded?: (e: GridAdaptiveRowExpandedEventArgs<T>) => void;
+    /** A row's adaptive detail is about to close; `e.cancel` keeps it open. */
+    onAdaptiveDetailRowCollapsing?: (e: GridAdaptiveRowExpandingEventArgs<T>) => void;
+    onAdaptiveDetailRowCollapsed?: (e: GridAdaptiveRowExpandedEventArgs<T>) => void;
+    /** The bar above the rows: which items, and whether it shows. */
+    toolbar?: GridToolbar;
+    /** What the toolbar's export button (`settings.exportButton`) offers: the formats, "Export selected rows", the texts. */
+    export?: GridExportSettings;
+    /** Initial filters, by field. Read and change them later through `grid.filters`. */
+    filters?: GridFilters;
+    /**
+     * The filter value, as the data layer has it: the filter builder's conditions, and with
+     * `settings.filterSyncEnabled` the filter row's and header filters' too (those they can show go
+     * to them). A function is followed; the user's changes come through `onFilterChanged` (`e.filterValue`).
+     */
+    filterValue?: Bind<data.FilterExpression | null>;
+    /** Whether the filter value applies: the filter panel's check box. A function is followed. Default `true`. */
+    filterEnabled?: Bind<boolean>;
+    /** The text of the filter panel, from the one it would show. */
+    filterPanelText?: (e: GridFilterPanelTextInfo) => string;
+    /** The filter builder the filter panel opens (any prop of `FilterBuilder` but `value` and `fields`). Read and change it later through `grid.filterBuilder`. */
+    filterBuilder?: GridFilterBuilderOptions;
+    /** The window the filter builder opens in. Read and change it later through `grid.filterBuilderPopup`. */
+    filterBuilderPopup?: GridFilterBuilderPopup;
+    /** The filter builder is about to open; `e.cancel` keeps it closed. */
+    onFilterBuilderOpening?: (e: GridFilterBuilderOpeningEventArgs) => void;
+    onFilterBuilderOpened?: (e: GridFilterBuilderOpenedEventArgs) => void;
+    /** The filter builder is about to close, with OK (`e.apply`) or not; `e.cancel` keeps it open. */
+    onFilterBuilderClosing?: (e: GridFilterBuilderClosingEventArgs) => void;
+    onFilterBuilderClosed?: (e: GridFilterBuilderClosedEventArgs) => void;
+    /**
+     * The values of a column's header filter, when the data comes from a server that cannot group:
+     * a part of the distinct values that honor the other filters. Without it, rows in memory and
+     * adapters that group give the values themselves.
+     */
+    loadValues?: (request: GridValuesRequest<T>) => GridValuesResult | Promise<GridValuesResult>;
+    /** A cell was clicked; `e.cancel` stops the grid's own handling (select, group, edit). */
+    onCellClick?: (e: GridCellClickEventArgs<T>) => void;
+    /** A cell was double-clicked; `e.cancel` keeps its editor closed. */
+    onCellDblClick?: (e: GridCellClickEventArgs<T>) => void;
+    /** A row was clicked (after its cell's event); `e.cancel` stops the grid's own handling. */
+    onRowClick?: (e: GridRowClickEventArgs<T>) => void;
+    /** A row was double-clicked; `e.cancel` keeps the editor closed. */
+    onRowDblClick?: (e: GridRowClickEventArgs<T>) => void;
+    /** A cell was drawn for a row: style it (the element is reused; set and clear what you change). */
+    onCellPrepared?: (e: GridCellPreparedEventArgs<T>) => void;
+    /** A row was drawn: style it (the element is reused; set and clear what you change). */
+    onRowPrepared?: (e: GridRowPreparedEventArgs<T>) => void;
+    /** Rows arrived and are laid out. */
+    onContentReady?: (e: GridContentReadyEventArgs) => void;
+    /** Loading or saving failed. */
+    onDataErrorOccurred?: (e: GridDataErrorEventArgs<T>) => void;
+    /** A cell editor, or a row's edit form, is about to open; `e.cancel` keeps it closed. */
+    onEditingStart?: (e: GridEditingStartEventArgs<T>) => void;
+    /** A new row is about to open: change `e.data` (what it starts with) or `e.values` (entered), or `e.cancel`. */
+    onInitNewRow?: (e: GridInitNewRowEventArgs<T>) => void;
+    /** Changes are about to be sent; `e.cancel` keeps them all unsent. */
+    onSaving?: (e: GridSavingEventArgs<T>) => void;
+    /** The answer to a save came. */
+    onSaved?: (e: GridSavedEventArgs<T>) => void;
+    /** A new row is about to be sent; change `e.data`, or `e.cancel`. */
+    onRowInserting?: (e: GridRowInsertingEventArgs<T>) => void;
+    onRowInserted?: (e: GridRowInsertedEventArgs<T>) => void;
+    /** A row's changes are about to be sent; change `e.changes`, or `e.cancel`. */
+    onRowUpdating?: (e: GridRowUpdatingEventArgs<T>) => void;
+    onRowUpdated?: (e: GridRowUpdatedEventArgs<T>) => void;
+    /** A row's deletion is about to be sent; `e.cancel` keeps the row. */
+    onRowRemoving?: (e: GridRowRemovingEventArgs<T>) => void;
+    onRowRemoved?: (e: GridRowRemovedEventArgs<T>) => void;
+    /** Unsaved changes are about to be dropped (Escape, "Cancel", `discardChanges()`); `e.cancel` keeps them. */
+    onEditCanceling?: (e: GridEditCancelingEventArgs<T>) => void;
+    onEditCanceled?: (e: GridEditCanceledEventArgs<T>) => void;
+    /** The active cell is about to move; `e.cancel` keeps it. */
+    onFocusedCellChanging?: (e: GridFocusedCellChangingEventArgs<T>) => void;
+    onFocusedCellChanged?: (e: GridFocusedCellChangedEventArgs<T>) => void;
+    /** The active row is about to change; `e.cancel` keeps it. */
+    onFocusedRowChanging?: (e: GridFocusedRowChangingEventArgs<T>) => void;
+    onFocusedRowChanged?: (e: GridFocusedRowChangedEventArgs<T>) => void;
+    /** A key is about to be handled by the grid (DevExtreme's `onKeyDown`); `e.cancel` stops the grid's handling. */
+    onKeyHandling?: (e: GridKeyHandlingEventArgs) => void;
+    /** A setting of the grid, a column or the toolbar was assigned, or a column was added or taken out (`name: 'columns'`). */
+    onOptionChanged?: (e: GridOptionChangedEventArgs) => void;
+    /** An export is about to start; change `e.options`, or `e.cancel`. */
+    onExporting?: (e: GridExportingEventArgs) => void;
+    onExported?: (e: GridExportedEventArgs) => void;
+    /** A column menu or a row's menu is about to open: change `e.items`, or `e.cancel`. */
+    onContextMenuPreparing?: (e: GridContextMenuPreparingEventArgs<T>) => void;
+    /** The toolbar is laid out: change `e.items`. */
+    onToolbarPreparing?: (e: GridToolbarPreparingEventArgs) => void;
+    /** The sort is about to change; `e.cancel` keeps it. */
+    onSortChanging?: (e: GridSortChangingEventArgs) => void;
+    onSortChanged?: (e: GridSortChangedEventArgs) => void;
+    /** The filters are about to apply; `e.cancel` puts the ones before back. */
+    onFilterChanging?: (e: GridFilterChangingEventArgs) => void;
+    onFilterChanged?: (e: GridFilterChangedEventArgs) => void;
+    /** Another page is about to show; `e.cancel` stays. */
+    onPageChanging?: (e: GridPageChangingEventArgs) => void;
+    onPageChanged?: (e: GridPageChangedEventArgs) => void;
+    /** The rows per page are about to change (the pager's page sizes, `pageSize(n)`); `e.cancel` keeps them. */
+    onPageSizeChanging?: (e: GridPageSizeChangingEventArgs) => void;
+    onPageSizeChanged?: (e: GridPageSizeChangedEventArgs) => void;
+    /** Infinite mode: the next part of the rows is about to load; `e.cancel` keeps the rows as they are. */
+    onMoreRowsLoading?: (e: GridMoreRowsLoadingEventArgs) => void;
+    /** Infinite mode: a part of the rows came. */
+    onMoreRowsLoaded?: (e: GridMoreRowsLoadedEventArgs) => void;
+    /** Cells are about to be copied; change `e.text` / `e.html`, or `e.cancel`. */
+    onCopying?: (e: GridCopyingEventArgs) => void;
+    /** Text is about to be pasted; change `e.text`, or `e.cancel`. */
+    onPasting?: (e: GridPastingEventArgs) => void;
+}

package/dist/components/datagrid/detail-context.d.ts

@@ -0,0 +1,13 @@
+import type { DataGrid } from './DataGrid';
+/** What `masterDetail.template` gets for a row. */
+export interface DetailContext<T> {
+    /** The row itself; read again in getters when the row shows another object (a refresh that loads it again), and on `grid.repaint()`. */
+    readonly row: T;
+    /** The row's key. */
+    readonly key: unknown;
+    /** The row's grid index now; reactive. */
+    readonly rowIndex: number;
+    readonly grid: DataGrid<T>;
+    /** Closes the details, as the user would (`onRowCollapsing` can keep them open). Returns whether they closed. */
+    collapse(): boolean;
+}

package/dist/components/datagrid/editor-context.d.ts

@@ -0,0 +1,26 @@
+import type { GridColumn } from './grid-column';
+import type { GridLookup } from './grid-lookup';
+/**
+ * What a custom editor receives. An editor that is a `Field` is read through its `value`; any other
+ * one writes its value with `setValue`. `commit()` keeps the value and closes the editor (like
+ * Enter), `cancel()` closes it without keeping it (like Escape). On a lookup column `setValue` also
+ * takes the text to show for the key.
+ */
+export interface EditorContext<T> {
+    /** 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 column: GridColumn<T>;
+    /** The column's lookup, when it has one. */
+    readonly lookup: GridLookup<T> | undefined;
+    /** The value when the editor opened. */
+    readonly value: unknown;
+    /** The character typed to start editing, if editing started by typing. */
+    readonly initialText: string | undefined;
+    setValue(value: unknown, text?: string): void;
+    commit(): void;
+    cancel(): void;
+}

package/dist/components/datagrid/grid-action-item.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltInAction } from './built-in-action';
+import type { GridAction } from './grid-action';
+/** An entry of the `actions` prop: an action, or the name of one the grid has ready. */
+export type GridActionItem<T> = GridAction<T> | BuiltInAction;

package/dist/components/datagrid/grid-action-location.d.ts

@@ -0,0 +1,2 @@
+/** Where an action shows: in its row, in the toolbar above the rows, or in the bar under them. */
+export type GridActionLocation = 'row' | 'toolbar' | 'bottom';

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

@@ -0,0 +1,17 @@
+import type { GridAction } from './grid-action';
+import type { GridActionLocation } from './grid-action-location';
+/** An action ran: on how many rows it worked, failed, and whether the user stopped it. */
+export interface GridActionRanEventArgs<T> {
+    readonly action: GridAction<T>;
+    readonly rows: readonly T[];
+    readonly location: GridActionLocation | 'contextMenu' | 'code';
+    readonly done: number;
+    readonly failed: number;
+    /** Stopped (Stop, `grid.stopAction()`) before every row was done. */
+    readonly canceled: boolean;
+    /** What the failed rows threw, with the row (`undefined` for `onclickMany` and `onclickSelection`). */
+    readonly errors: readonly {
+        row: T | undefined;
+        error: unknown;
+    }[];
+}

package/dist/components/datagrid/grid-action-run.d.ts

@@ -0,0 +1,10 @@
+import type { GridActionLocation } from './grid-action-location';
+/** What `onclickMany` and `onclickSelection` get besides the rows. */
+export interface GridActionRun {
+    /** Where the action was pressed; `'contextMenu'` from a row's menu, `'code'` from `grid.runAction`. */
+    readonly location: GridActionLocation | 'contextMenu' | 'code';
+    /** Aborted when the user presses Stop (or the grid goes away). */
+    readonly signal: AbortSignal;
+    /** Moves the progress bar: rows done so far, of `total` (default: the rows it runs on). */
+    progress(done: number, total?: number): void;
+}

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

@@ -0,0 +1,13 @@
+import type { EventArgs } from '@motifx/core';
+import type { GridAction } from './grid-action';
+import type { GridActionLocation } from './grid-action-location';
+import type { GridSelection } from './grid-selection';
+/** An action is about to run; `cancel` keeps it from running. */
+export interface GridActionRunningEventArgs<T> extends EventArgs {
+    readonly action: GridAction<T>;
+    /** The rows it runs on; empty when it runs on a selection whose rows are not loaded. */
+    readonly rows: readonly T[];
+    /** The selection it runs on, when it acts on the selected rows; else `null`. */
+    readonly selection: GridSelection | null;
+    readonly location: GridActionLocation | 'contextMenu' | 'code';
+}