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

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

@@ -0,0 +1,34 @@
+import type { Bind } from '@motifx/core';
+import type { IconSource } from '../../core/icon-source';
+import type { GridToolbarItemClickEventArgs } from './grid-toolbar-item-click-event-args';
+/**
+ * An item of the grid's toolbar: a button of your own, your own component (`content`), or one of the
+ * grid's items (`name`) with some of its fields changed. Every field but `name`, `content` and
+ * `click` is a value or a function that is followed.
+ *
+ * @example
+ * { text: 'Refresh', icon: () => refreshIcon(), location: 'before', click: () => grid.refresh() }
+ * { name: 'exportButton', showText: 'always' }
+ */
+export interface GridToolbarItem {
+    /** One of the grid's items to change, or a name of your own for this item. */
+    name?: string;
+    /** Which end of the toolbar it sits at. Default `'after'`; the group panel `'before'`. */
+    location?: Bind<'before' | 'after'>;
+    text?: Bind<string>;
+    icon?: Bind<IconSource | null | undefined>;
+    /** A tooltip; the name of a button that shows only its icon. Default: `text`. */
+    hint?: Bind<string>;
+    /** Show the text in the toolbar, or only in its "more" menu (the icon alone in the bar). Default `'always'`; the grid's buttons `'inMenu'`. */
+    showText?: Bind<'always' | 'inMenu'>;
+    /** `false` leaves the item out. Default `true`. */
+    visible?: Bind<boolean>;
+    /** `false` dims the item; it cannot be pressed. Default `true`. */
+    enabled?: Bind<boolean>;
+    /** Whether it may move into the "more" menu: when it does not fit, always, or never. Default `'never'`; the grid's buttons `'auto'`. */
+    overflow?: Bind<'auto' | 'always' | 'never'>;
+    /** Your own component in place of a button: made once, when the item first shows. */
+    content?: () => unknown;
+    /** Runs when the button is pressed, in the bar or in the "more" menu. On one of the grid's items it replaces what the item does. */
+    click?: (e: GridToolbarItemClickEventArgs) => void;
+}

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

@@ -0,0 +1,9 @@
+import type { GridToolbarItem } from './grid-toolbar-item';
+import type { GridToolbarItemName } from './grid-toolbar-item-name';
+/**
+ * The toolbar is laid out (when the grid is made and whenever what it shows changes). `items` are
+ * the items it takes, as `toolbar.items` would list them: change the list to change the bar.
+ */
+export interface GridToolbarPreparingEventArgs {
+    items: (GridToolbarItem | GridToolbarItemName)[];
+}

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

@@ -0,0 +1,15 @@
+import type { Bind } from '@motifx/core';
+import type { GridToolbarItem } from './grid-toolbar-item';
+import type { GridToolbarItemName } from './grid-toolbar-item-name';
+/**
+ * The bar above the rows. Without `items` it holds the grid's own items whose features are on, in
+ * this order: the group panel (at the start), "New row", "Save changes", "Discard", "Export", the
+ * column list, the search box. With
+ * `items` it holds exactly those, in that order; one of the grid's items whose feature is off stays
+ * out. Read and change it later through `grid.toolbar`.
+ */
+export interface GridToolbar {
+    /** `true` always shows the bar, `false` never; left out, it shows while it has an item. */
+    visible?: Bind<boolean | undefined>;
+    items?: Bind<readonly (GridToolbarItem | GridToolbarItemName)[] | undefined>;
+}

package/dist/components/datagrid/grid-validation-callback-args.d.ts

@@ -0,0 +1,13 @@
+import type { data } from '@motifx-community/data';
+import type { GridColumn } from './grid-column';
+import type { GridValidationRule } from './grid-validation-rule';
+/** What a `custom` or `async` rule checks. */
+export interface GridValidationCallbackArgs<T> {
+    readonly value: unknown;
+    /** The row itself. */
+    readonly row: T;
+    /** The other values of the row: the entered ones (`values`), `isNew`, and `getValue(field)`, the value a field is saved with. */
+    readonly context: data.RowCheckContext<T>;
+    readonly column: GridColumn<T>;
+    readonly rule: GridValidationRule<T>;
+}

package/dist/components/datagrid/grid-validation-rule.d.ts

@@ -0,0 +1,74 @@
+import type { Bind } from '@motifx/core';
+import type { data } from '@motifx-community/data';
+import type { GridValidationCallbackArgs } from './grid-validation-callback-args';
+/**
+ * One check of a column's value, DevExtreme's rule set. Without a `message` the text comes from
+ * `uiLocale`. `ignoreEmptyValue` lets an empty value pass (default: `true` for `numeric`, `range`,
+ * `pattern` and `email`, `false` for the others); `reevaluate` runs the rule on every check of the row,
+ * not only when the value changed (default: `true` for `async`, `false` for the others). The
+ * rules run in order, the `async` ones last and together; the first that fails gives the message.
+ */
+export type GridValidationRule<T = any> = {
+    type: 'required';
+    message?: Bind<string>;
+    trim?: boolean;
+} | {
+    type: 'numeric';
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+} | {
+    type: 'range';
+    min?: Bind<number | Date>;
+    max?: Bind<number | Date>;
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+    reevaluate?: boolean;
+} | {
+    type: 'stringLength';
+    min?: Bind<number>;
+    max?: Bind<number>;
+    trim?: boolean;
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+}
+/** A string pattern is found anywhere in the value, as `new RegExp(pattern)` would. */
+ | {
+    type: 'pattern';
+    pattern: Bind<RegExp | string>;
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+} | {
+    type: 'email';
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+}
+/** The value compared with what `comparisonTarget` returns (a repeated password: `context.getValue('password')`). Default `'=='`. */
+ | {
+    type: 'compare';
+    comparisonTarget: (row: T, context: data.RowCheckContext<T>) => unknown;
+    comparisonType?: '==' | '!=' | '===' | '!==' | '<' | '<=' | '>' | '>=';
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+}
+/** `true` passes, `false` fails, a string fails with that text. */
+ | {
+    type: 'custom';
+    validationCallback: (e: GridValidationCallbackArgs<T>) => boolean | string | null | undefined | void;
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+    reevaluate?: boolean;
+}
+/**
+ * Checked on the server: the promise resolves to `true` (or nothing), `false`, a message, or
+ * `{ isValid, message }`; a rejection fails with its message.
+ */
+ | {
+    type: 'async';
+    validationCallback: (e: GridValidationCallbackArgs<T>) => PromiseLike<boolean | string | {
+        isValid: boolean;
+        message?: string;
+    } | null | undefined | void>;
+    message?: Bind<string>;
+    ignoreEmptyValue?: boolean;
+    reevaluate?: boolean;
+};

package/dist/components/datagrid/grid-values-request.d.ts

@@ -0,0 +1,13 @@
+import type { data } from '@motifx-community/data';
+import type { GridColumn } from './grid-column';
+/** What `loadValues` is asked for: a part of the distinct values of a column. */
+export interface GridValuesRequest<T> {
+    column: GridColumn<T>;
+    /** The text typed in the list's search box. */
+    search: string;
+    /** The other filters of the grid (and the source's own), which the values should honor. */
+    filter: data.FilterExpression | null;
+    skip: number;
+    take: number;
+    signal: AbortSignal;
+}

package/dist/components/datagrid/grid-values-result.d.ts

@@ -0,0 +1,6 @@
+import type { GridFilterValue } from './grid-filter-value';
+/** What `loadValues` answers: a part of the values and how many there are in all. */
+export interface GridValuesResult {
+    values: GridFilterValue[];
+    total: number;
+}

package/dist/components/datagrid/grid-visible-row.d.ts

@@ -0,0 +1,12 @@
+import type { GridRowType } from './grid-row-type';
+/** A row drawn on the screen now (`getVisibleRows()`). */
+export interface GridVisibleRow<T> {
+    readonly rowIndex: number;
+    readonly rowType: GridRowType;
+    /** The row; `undefined` on a group row or while it loads. */
+    readonly row: T | undefined;
+    /** The row's key; `undefined` on a new row, a group row or while it loads. */
+    readonly key: unknown;
+    readonly groupKey?: readonly unknown[];
+    readonly element: HTMLElement;
+}

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

@@ -0,0 +1,22 @@
+import type { GridColumn } from './grid-column';
+import type { GridSummaryValue } from './grid-summary-value';
+/**
+ * What a column's own group cell (`groupCell`) receives. The grid reuses the group row for other
+ * groups while it scrolls, so read the fields inside getters (`{() => ctx.text}`).
+ */
+export interface GroupCellContext<T> {
+    /** The value the group's rows share; `null` for empty values. */
+    readonly value: unknown;
+    /** The value as the column shows it (a lookup's text). */
+    readonly text: string;
+    /** Rows in the group, levels below included. */
+    readonly count: number;
+    /** 0 for the top level. */
+    readonly level: number;
+    /** The values of the groups from the top level down to this one: the group's key for `expandGroup`. */
+    readonly key: readonly unknown[];
+    readonly isExpanded: boolean;
+    /** The group summary items of the group row (not of its footer) with their values and texts. */
+    readonly summaryItems: readonly GridSummaryValue[];
+    readonly column: GridColumn<T>;
+}

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

@@ -0,0 +1,9 @@
+import type { GridColumn } from './grid-column';
+/** What a column's `headerCell` content gets: read its fields inside getters. */
+export interface HeaderCellContext<T> {
+    readonly column: GridColumn<T>;
+    /** The title, as `title` gives it now. */
+    readonly title: string;
+    /** The column's sort order now; `null` when it is not sorted. */
+    readonly sort: 'asc' | 'desc' | null;
+}

package/dist/components/datagrid/index.d.ts

@@ -0,0 +1,161 @@
+export { DataGrid } from './DataGrid';
+export type { DataGridProps } from './data-grid-props';
+export type { GridColumn } from './grid-column';
+export type { GridBand } from './grid-band';
+export type { GridColumnItem } from './grid-column-item';
+export type { BandCellContext } from './band-cell-context';
+export type { BandLayout } from './band-layout';
+export type { GridSheetMerge } from './grid-sheet-merge';
+export type { GridAdaptiveDetail } from './grid-adaptive-detail';
+export type { GridAdaptiveFormOptions } from './grid-adaptive-form-options';
+export type { GridAdaptiveDetailRowPreparingEventArgs } from './grid-adaptive-detail-row-preparing-event-args';
+export type { GridAdaptiveRowExpandingEventArgs } from './grid-adaptive-row-expanding-event-args';
+export type { GridAdaptiveRowExpandedEventArgs } from './grid-adaptive-row-expanded-event-args';
+export type { GridLookup } from './grid-lookup';
+export type { GridEditorPreparingEventArgs } from './grid-editor-preparing-event-args';
+export type { GridEditorPreparedEventArgs } from './grid-editor-prepared-event-args';
+export type { GridValidationRule } from './grid-validation-rule';
+export type { GridValidationCallbackArgs } from './grid-validation-callback-args';
+export type { GridRowValidatingEventArgs } from './grid-row-validating-event-args';
+export type { GridColumnFormItem } from './grid-column-form-item';
+export type { GridEditForm } from './grid-edit-form';
+export type { GridEditPopup } from './grid-edit-popup';
+export type { GridMasterDetail } from './grid-master-detail';
+export type { GridRowDragging } from './grid-row-dragging';
+export type { GridRowDragEventArgs } from './grid-row-drag-event-args';
+export type { GridRowDropEventArgs } from './grid-row-drop-event-args';
+export type { DetailContext } from './detail-context';
+export type { GridSettings } from './grid-settings';
+export type { GridSettingsProps } from './grid-settings-props';
+export type { ColumnFeatures } from './column-features';
+export type { ColumnType } from './column-type';
+export type { CellContext } from './cell-context';
+export type { EditorContext } from './editor-context';
+export type { ListOption } from './list-option';
+export type { GridLayout } from './grid-layout';
+export type { ColumnLayout } from './column-layout';
+export type { StickySide } from './sticky-side';
+export type { ColumnResizeMode } from './column-resize-mode';
+export type { GridMode } from './grid-mode';
+export type { GridChanges } from './grid-changes';
+export type { RowChange } from './row-change';
+export type { NewRowOptions } from './new-row-options';
+export type { GridAction } from './grid-action';
+export type { GridActionItem } from './grid-action-item';
+export type { GridActionLocation } from './grid-action-location';
+export type { GridActionRun } from './grid-action-run';
+export type { GridActionRunningEventArgs } from './grid-action-running-event-args';
+export type { GridActionRanEventArgs } from './grid-action-ran-event-args';
+export type { GridBarAction } from './grid-bar-action';
+export type { BuiltInAction } from './built-in-action';
+export type { GridBuiltInActions } from './grid-built-in-actions';
+export type { RowState } from './row-state';
+export type { SelectionMode } from './selection-mode';
+export type { GridSelection } from './grid-selection';
+export type { GridSelectionChangedEventArgs } from './grid-selection-changed-event-args';
+export type { GridCellPoint } from './grid-cell-point';
+export type { GridCellRange } from './grid-cell-range';
+export type { GridCellValue } from './grid-cell-value';
+export type { GridCellSummary } from './grid-cell-summary';
+export type { GridCellSummaryItem } from './grid-cell-summary-item';
+export type { GridCellExtendKeys } from './grid-cell-extend-keys';
+export type { GridRowExtendKeys } from './grid-row-extend-keys';
+export type { GridCellSelectionChangingEventArgs } from './grid-cell-selection-changing-event-args';
+export type { GridCellSelectionChangedEventArgs } from './grid-cell-selection-changed-event-args';
+export type { GridFilterOperator } from './grid-filter-operator';
+export type { ColumnFilter } from './column-filter';
+export type { GridFilters } from './grid-filters';
+export type { GridFilterValue } from './grid-filter-value';
+export type { GridDateInterval } from './grid-date-interval';
+export type { GridHeaderFilterInterval } from './grid-header-filter-interval';
+export type { GridHeaderFilterItems } from './grid-header-filter-items';
+export type { GridHeaderFilterItemsRequest } from './grid-header-filter-items-request';
+export type { GridValuesRequest } from './grid-values-request';
+export type { GridValuesResult } from './grid-values-result';
+export type { GridExportOptions } from './grid-export-options';
+export type { GridExportSettings } from './grid-export-settings';
+export type { GridExportTexts } from './grid-export-texts';
+export type { GridLoadPanel } from './grid-load-panel';
+export type { GridExportCell } from './grid-export-cell';
+export type { GridSheet } from './grid-sheet';
+export type { GridSheetColumn } from './grid-sheet-column';
+export type { GridSheetRow } from './grid-sheet-row';
+export type { GridSheetCell } from './grid-sheet-cell';
+export type { GridSheetOptions } from './grid-sheet-options';
+export type { GridToolbar } from './grid-toolbar';
+export type { GridToolbarItem } from './grid-toolbar-item';
+export type { GridToolbarItemName } from './grid-toolbar-item-name';
+export type { GridToolbarItemClickEventArgs } from './grid-toolbar-item-click-event-args';
+export type { GridSearchTextChangedEventArgs } from './grid-search-text-changed-event-args';
+export type { GroupCellContext } from './group-cell-context';
+export type { GridSummary } from './grid-summary';
+export type { GridSummaryItem } from './grid-summary-item';
+export type { GridGroupSummaryItem } from './grid-group-summary-item';
+export type { GridSummaryType } from './grid-summary-type';
+export type { GridSummaryTexts } from './grid-summary-texts';
+export type { GridSummaryTextInfo } from './grid-summary-text-info';
+export type { GridSummaryValue } from './grid-summary-value';
+export type { GridCustomSummaryInfo } from './grid-custom-summary-info';
+export type { GridSummaryChangedEventArgs } from './grid-summary-changed-event-args';
+export type { GridRowExpandingEventArgs } from './grid-row-expanding-event-args';
+export type { GridRowExpandedEventArgs } from './grid-row-expanded-event-args';
+export type { GridGroupingChangingEventArgs } from './grid-grouping-changing-event-args';
+export type { GridGroupingChangedEventArgs } from './grid-grouping-changed-event-args';
+export type { GridGroupDroppingEventArgs } from './grid-group-dropping-event-args';
+export type { GridRowType } from './grid-row-type';
+export type { GridCellClickEventArgs } from './grid-cell-click-event-args';
+export type { GridRowClickEventArgs } from './grid-row-click-event-args';
+export type { GridCellPreparedEventArgs } from './grid-cell-prepared-event-args';
+export type { GridRowPreparedEventArgs } from './grid-row-prepared-event-args';
+export type { GridContentReadyEventArgs } from './grid-content-ready-event-args';
+export type { GridDataErrorEventArgs } from './grid-data-error-event-args';
+export type { GridEditingStartEventArgs } from './grid-editing-start-event-args';
+export type { GridInitNewRowEventArgs } from './grid-init-new-row-event-args';
+export type { GridRowInsertingEventArgs } from './grid-row-inserting-event-args';
+export type { GridRowInsertedEventArgs } from './grid-row-inserted-event-args';
+export type { GridRowUpdatingEventArgs } from './grid-row-updating-event-args';
+export type { GridRowUpdatedEventArgs } from './grid-row-updated-event-args';
+export type { GridRowRemovingEventArgs } from './grid-row-removing-event-args';
+export type { GridRowRemovedEventArgs } from './grid-row-removed-event-args';
+export type { GridSavingEventArgs } from './grid-saving-event-args';
+export type { GridSavedEventArgs } from './grid-saved-event-args';
+export type { GridEditCancelingEventArgs } from './grid-edit-canceling-event-args';
+export type { GridEditCanceledEventArgs } from './grid-edit-canceled-event-args';
+export type { GridFocusedCellChangingEventArgs } from './grid-focused-cell-changing-event-args';
+export type { GridFocusedCellChangedEventArgs } from './grid-focused-cell-changed-event-args';
+export type { GridFocusedRowChangingEventArgs } from './grid-focused-row-changing-event-args';
+export type { GridFocusedRowChangedEventArgs } from './grid-focused-row-changed-event-args';
+export type { GridKeyHandlingEventArgs } from './grid-key-handling-event-args';
+export type { GridOptionChangedEventArgs } from './grid-option-changed-event-args';
+export type { GridExportingEventArgs } from './grid-exporting-event-args';
+export type { GridExportedEventArgs } from './grid-exported-event-args';
+export type { GridContextMenuPreparingEventArgs } from './grid-context-menu-preparing-event-args';
+export type { GridToolbarPreparingEventArgs } from './grid-toolbar-preparing-event-args';
+export type { GridSelectionChangingEventArgs } from './grid-selection-changing-event-args';
+export type { GridSortChangingEventArgs } from './grid-sort-changing-event-args';
+export type { GridSortChangedEventArgs } from './grid-sort-changed-event-args';
+export type { GridFilterChangingEventArgs } from './grid-filter-changing-event-args';
+export type { GridFilterChangedEventArgs } from './grid-filter-changed-event-args';
+export type { GridFilterBuilderOptions } from './grid-filter-builder-options';
+export type { GridFilterBuilderPopup } from './grid-filter-builder-popup';
+export type { GridFilterPanelTextInfo } from './grid-filter-panel-text-info';
+export type { GridFilterBuilderOpeningEventArgs } from './grid-filter-builder-opening-event-args';
+export type { GridFilterBuilderOpenedEventArgs } from './grid-filter-builder-opened-event-args';
+export type { GridFilterBuilderClosingEventArgs } from './grid-filter-builder-closing-event-args';
+export type { GridFilterBuilderClosedEventArgs } from './grid-filter-builder-closed-event-args';
+export type { GridPageChangingEventArgs } from './grid-page-changing-event-args';
+export type { GridPageChangedEventArgs } from './grid-page-changed-event-args';
+export type { GridPageSizeChangingEventArgs } from './grid-page-size-changing-event-args';
+export type { GridPageSizeChangedEventArgs } from './grid-page-size-changed-event-args';
+export type { GridMoreRowsLoadingEventArgs } from './grid-more-rows-loading-event-args';
+export type { GridMoreRowsLoadedEventArgs } from './grid-more-rows-loaded-event-args';
+export type { GridLayoutChangingEventArgs } from './grid-layout-changing-event-args';
+export type { GridSearchTextChangingEventArgs } from './grid-search-text-changing-event-args';
+export type { GridCopyingEventArgs } from './grid-copying-event-args';
+export type { GridPastingEventArgs } from './grid-pasting-event-args';
+export type { GridVisibleRow } from './grid-visible-row';
+export type { GridEditingCell } from './grid-editing-cell';
+export type { GridStateValue } from './grid-state-value';
+export type { ColumnOptionName } from './column-option-name';
+export type { HeaderCellContext } from './header-cell-context';
+export type { LayoutStorage } from './layout-storage';

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

@@ -0,0 +1,6 @@
+/** Where the layout of a grid with `layoutKey` is kept: `localStorage` (default), `sessionStorage`, or your own. */
+export interface LayoutStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}

package/dist/components/datagrid/list-option.d.ts

@@ -0,0 +1,5 @@
+/** An entry of a `list` column: a plain value, or a value with its display text. */
+export type ListOption = string | number | boolean | {
+    value: unknown;
+    label: string;
+};

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

@@ -0,0 +1,28 @@
+import type { GridActionRanEventArgs } from '../grid-action-ran-event-args';
+import type { GridActionRun } from '../grid-action-run';
+import type { ActionEntry } from './action-entry';
+import type { GridModel } from './GridModel';
+import type { RunPanel } from './run-panel';
+type Place = GridActionRun['location'];
+/**
+ * Runs an action on its rows: `onclickMany` once with all of them, else `onclick` for each row in
+ * turn (waiting for a promise), or `onclickSelection` with the selection. Work that waits shows the
+ * progress panel with Stop; a failed row does not stop the others unless `stopOnError`. The outcome
+ * is announced and told through `onActionRan`. Plain functions run at once, in the same task.
+ */
+export declare class ActionRunner<T> {
+    private readonly model;
+    private readonly panel;
+    private controller;
+    constructor(model: GridModel<T>, panel: RunPanel);
+    /** Stops the action running now: the rows not started are left. */
+    stop(): void;
+    dispose(): void;
+    /** Runs an entry, after `onActionRunning`; `null` when it is disabled, another one runs, or the event cancels it. */
+    run(entry: ActionEntry<T>, location: Place): Promise<GridActionRanEventArgs<T> | null>;
+    private work;
+    private announce;
+    /** Loaded rows as a selection of their keys, for an action that only takes a selection. */
+    private keysOf;
+}
+export {};

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

@@ -0,0 +1,64 @@
+import type { GridAction } from '../grid-action';
+import type { GridActionItem } from '../grid-action-item';
+import type { GridActionLocation } from '../grid-action-location';
+import type { RowState } from '../row-state';
+import type { ActionEntry } from './action-entry';
+import type { ActionTarget } from './action-target';
+import type { GridModel } from './GridModel';
+/**
+ * Which rows the toolbar and the bottom bar act on, and the actions those rows share: one row's
+ * own actions, or the ones every row has (same `id`, visible for each), disabled as
+ * `actionsMultipleEnabled` says. Reads are reactive: the bars follow the selection, the active row
+ * and the rows' states. The rows drawn tell what they hold, so the actions column shows only while
+ * an action sits in the row.
+ */
+export declare class ActionSets<T> {
+    private readonly model;
+    /** `version` grows on `refresh()`: the actions are asked again. */
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    private readonly marks;
+    private readonly drawn;
+    constructor(model: GridModel<T>);
+    /** Grows when the actions are asked again (`refresh()`). Reactive. */
+    get version(): number;
+    /** The rows and the bars ask their actions again: what an action or the `actions` function reads changed. */
+    refresh(): void;
+    /** The action of an entry of the `actions` prop. */
+    resolve(item: GridActionItem<T>): GridAction<T> | undefined;
+    locationOf(action: GridAction<T>): GridActionLocation;
+    menuOf(action: GridAction<T>): 'auto' | 'always' | 'never';
+    inContextMenu(action: GridAction<T>): boolean;
+    /** Whether some action sits in the row: the column shows while one does. Reactive. */
+    inRow(): boolean;
+    /** Whether actions can show in a bar: one of the listed ones sits there (with a function: maybe). Reactive. */
+    canShowIn(location: GridActionLocation): boolean;
+    /** Whether an action in the row stays a button even in the `'menu'` display. Reactive. */
+    anyNever(): boolean;
+    /** A drawn row tells what its actions hold (with `actions` as a function the grid learns it from the rows). */
+    markRow(holder: object, inRow: boolean, never: boolean): void;
+    /** What the bars act on now, by `actionsTarget`. Reactive. */
+    target(): ActionTarget<T>;
+    /** The active row, when it is a loaded data row. */
+    focusedTarget(): ActionTarget<T>;
+    /** The selected rows; the selection as a state when some of them are not loaded. */
+    selectionTarget(): ActionTarget<T>;
+    /** The actions the bar at `location` shows now. Reactive. */
+    barEntries(location: GridActionLocation): ActionEntry<T>[];
+    /** The actions a target's rows share, among those `keep` takes. Reactive. */
+    entries(target: ActionTarget<T>, keep: (action: GridAction<T>) => boolean): ActionEntry<T>[];
+    /** A row's text with the count of rows it runs on, as the buttons and menus show it. */
+    label(entry: ActionEntry<T>): string;
+    /** The name a screen reader gives the action: its text and how many rows it runs on. */
+    spokenLabel(entry: ActionEntry<T>): string;
+    /** What the bars act on, in words ("Actions for 3 selected rows"); `''` for nothing. Reactive. */
+    targetLabel(): string;
+    /** A row with its state, as its actions see it. */
+    itemOf(row: T): {
+        row: T;
+        state: RowState;
+    };
+    /** Rows not loaded: only the listed actions that work on a selection, without asking a row. */
+    private selectionEntries;
+}

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

@@ -0,0 +1,24 @@
+import type { GridAdaptiveDetail } from '../grid-adaptive-detail';
+import type { AdaptiveDetailValues } from './adaptive-detail-values';
+import { Switches } from './Switches';
+/**
+ * Which row has its adaptive detail open (one at a time, as in DevExtreme), by the grid's row id, so
+ * a new row can have it too; and the detail's options.
+ */
+export declare class AdaptiveRow {
+    readonly options: Switches<AdaptiveDetailValues>;
+    /** `rowId` of the open row; `auto` when editing opened it. Reactive. */
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        rowId: string | null;
+        auto: boolean;
+    };
+    /** The data key of the open row, as the data has it; it changes with `state.rowId`. */
+    key: unknown;
+    constructor(given: GridAdaptiveDetail | undefined);
+    isOpen(rowId: string | undefined): boolean;
+    open(rowId: string, key: unknown, auto?: boolean): void;
+    close(): void;
+}

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

@@ -0,0 +1,41 @@
+import type { GridColumn } from '../grid-column';
+import type { EditorValue } from '../view/editor-value';
+/** Cell values as text and back, by column type, with `Intl` in one locale; also the record counts. */
+export declare class CellFormatter {
+    readonly locale: string;
+    private readonly yesNo;
+    private readonly messages;
+    /** Texts read as yes and as no, besides the yes / no words. */
+    private readonly boolTexts;
+    readonly collator: Intl.Collator;
+    private readonly number;
+    private readonly date;
+    /** Formatters of the columns' own `Intl` options. */
+    private readonly own;
+    constructor(locale: string, yesNo: () => [string, string], messages?: () => {
+        number: string;
+        date: string;
+        other: string;
+    }, 
+    /** Texts read as yes and as no, besides the yes / no words. */
+    boolTexts?: () => [readonly string[], readonly string[]]);
+    /** A plain number: record counts, page numbers. */
+    count(n: number): string;
+    /** Display text of a cell; `v` is the value to show (the unsaved edit, when there is one). */
+    text<T>(col: GridColumn<T>, row: T | undefined, v: unknown): string;
+    /** The `Intl` options a number column shows its values with; `undefined` when its `format` is a function. */
+    numberOptions<T>(col: GridColumn<T>): Intl.NumberFormatOptions | undefined;
+    /** The `Intl` options a date column shows its values with; `undefined` when its `format` is a function. */
+    dateOptions<T>(col: GridColumn<T>): Intl.DateTimeFormatOptions | undefined;
+    /** A value as plain text in no locale's format: numbers as written in code, dates as `yyyy-mm-dd` (with the time when it has one), `true` / `false`. */
+    raw<T>(col: GridColumn<T>, v: unknown): string;
+    /**
+     * Text typed or pasted into a cell, read as the column's value: a number in the locale (or as
+     * written in code), a date in the locale's order or ISO (kept in the kind of value `like` is), yes
+     * or no, a list option by its text or value. Empty text is no value.
+     */
+    parse<T>(col: GridColumn<T>, text: string, like: unknown): EditorValue;
+    private numberFormat;
+    private dateFormat;
+    private optionLabel;
+}