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

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

@@ -0,0 +1,72 @@
+import { Component, ComponentBase } from '@motifx/core';
+import { type GridModel } from '../model/GridModel';
+import type { HeaderHost } from './header-host';
+/**
+ * The header row: a header per column with its title, sort mark, filter and menu buttons and resize
+ * handle. A click sorts (Shift adds to the sort), dragging a header moves the column inside its
+ * sticky zone and its band (or, dropped on the group panel, groups by it), dragging the edge resizes it, a
+ * double-click on the edge fits it to its content. The selection column's header is the "select all"
+ * check box. It follows nothing: made in code, it draws itself again whenever the grid tells a change.
+ */
+export declare class HeaderRow<T> extends Component<HTMLDivElement> {
+    private readonly grid;
+    private readonly host;
+    readonly cells: Map<string, ComponentBase<any, any>>;
+    /** The columns' own header contents (`headerCell`) that are components, by field. */
+    private readonly titles;
+    private indicator;
+    private suppressClick;
+    /** The parts of each header that show what changes, by field. */
+    private readonly drawn;
+    /** The "select all" check box and its header, while the grid has a selection column. */
+    private select;
+    constructor(grid: GridModel<T>, host: HeaderHost);
+    onConfigured(): void;
+    initializeComponent(): void;
+    /** Draws the row and every header as the grid is now. */
+    draw(): void;
+    onBuilt(): void;
+    /** Puts the headers in display order and numbers the visible ones; while columns are virtual, only the columns drawn have their header in the row. */
+    arrange(visible: string[]): void;
+    /** A column's own `headerCell` content in place of the title text. */
+    private ownTitle;
+    cellElement(field: string): HTMLElement | undefined;
+    /** A column added at run time gets its header (placed by the next `arrange`). */
+    addColumn(field: string): void;
+    /** A column taken out loses its header, and its own header content. */
+    removeColumn(field: string): void;
+    private cell;
+    /** A header as the grid is now: its title, sort, buttons and handle. */
+    private drawCell;
+    /** What a header says: a column's title, or the name of one of the grid's own columns. */
+    private titleOf;
+    /** The header of the selection column: the "select all" check box, shown while select all is on. */
+    private selectCell;
+    private drawSelect;
+    /** The sort position, shown next to the arrow when more than one column is sorted. */
+    private sortMark;
+    private clickHeader;
+    /**
+     * Drag a header to move the column within its zone and its band, not across columns that cannot
+     * move; onto the group panel to group by it.
+     */
+    private pressHeader;
+    /**
+     * Where a grouped column dragged back over the headers would land: its place among the visible
+     * columns of its zone and band; -1 when the point is not over the headers.
+     */
+    chipDropIndex(field: string, x: number, y?: number): number;
+    /** Where a column, or a band's columns together, sit on the screen. */
+    unitRect(id: string): {
+        left: number;
+        right: number;
+    };
+    /** Where a column's header sits on the screen; a column without cells (virtual, out of view) by the widths. */
+    private placeOf;
+    /** Marks where a grouped column dragged over the headers lands; whether the point is over them (NaN hides the mark). */
+    showChipDrop(field: string, x: number, y: number): boolean;
+    /** Width the column takes on screen; more than its setting while it flexes. */
+    shownWidth(field: string): number;
+    /** Drag the edge to resize: the column alone, or against the next one. */
+    private pressHandle;
+}

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

@@ -0,0 +1,19 @@
+import type { ComponentBase } from '@motifx/core';
+import { MenuList } from '../../../parts/menu/MenuList';
+import type { MenuItem } from '../../../parts/menu/menu-item';
+import { Popup } from '../../../parts/popup/Popup';
+/**
+ * One kit `MenuList` in a `Popup`, shared by every row (the "more" menu of the actions) or every
+ * filter cell (the conditions): opened next to the button that asks, focus inside, back on the
+ * button when it closes. Tab closes it.
+ */
+export declare class MenuPopup {
+    readonly popup: Popup;
+    readonly list: MenuList;
+    constructor(owner: ComponentBase, className: string, placement?: Popup['placement']);
+    get opened(): boolean;
+    open(items: readonly MenuItem[], anchor: HTMLElement, label: string, returnTo?: HTMLElement): void;
+    /** Focuses the item that is checked (a condition), else the first. */
+    focusChecked(): void;
+    close(): void;
+}

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

@@ -0,0 +1,30 @@
+import type { ActionWidths } from './ActionWidths';
+import type { ResolvedAction } from './resolved-action';
+/**
+ * The buttons of one pooled row's actions cell. The first actions that fit the column show as
+ * buttons, in order; the rest go into the "more" menu at the end. An action's `menu` keeps it in the
+ * menu always or never; the `'menu'` display puts every other one there. Buttons are reused as the
+ * row shows other rows.
+ */
+export declare class RowActions<T> {
+    readonly cell: HTMLElement;
+    private readonly widths;
+    /** Actions shown as buttons, in order. */
+    shown: ResolvedAction<T>[];
+    /** Actions of the "more" menu. */
+    overflow: ResolvedAction<T>[];
+    private readonly buttons;
+    private more;
+    constructor(cell: HTMLElement, widths: ActionWidths);
+    draw(list: ResolvedAction<T>[], width: number, more: {
+        label: string;
+        hint: string;
+    }, display: 'auto' | 'menu'): void;
+    /** The buttons that show, the "more" button last: what Left and Right move between. */
+    focusables(): HTMLButtonElement[];
+    /** The action of a button; `'more'` for the "more" button. */
+    actionOf(el: Element): ResolvedAction<T> | 'more' | null;
+    private createMore;
+    /** The actions that show as buttons in `width` pixels: all when they fit, else the ones kept as buttons and, in order, as many others as fit next to the "more" button. */
+    private fit;
+}

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

@@ -0,0 +1,79 @@
+import type { GridModel } from '../model/GridModel';
+import type { GridBody } from './GridBody';
+import type { RowDragHost } from './row-drag-host';
+/**
+ * Row drag and drop (`rowDragging`): a row taken by its drag icon (or anywhere, or by `handle`) and
+ * dragged past `dragThreshold` follows the pointer as a copy; the grid under the pointer shows where
+ * it would land (a line between the rows, the rows making room with `'push'`, or the row it would go
+ * onto) and scrolls near its edges. Dropped, it raises `onReorder` here, or `onRemove` here and
+ * `onAdd` on another grid of the same `group`; the handlers move the data. The same moves come from
+ * the keyboard (`moveUpKeys` / `moveDownKeys`) and `moveRow()`, with the same events, and are
+ * announced.
+ */
+export declare class RowDrag<T> {
+    private readonly model;
+    private readonly body;
+    private readonly host;
+    private session;
+    private readonly stops;
+    /** This grid shows marks of a drag. */
+    private marked;
+    constructor(model: GridModel<T>, body: GridBody<T>, host: RowDragHost<T>);
+    get options(): import("../model/RowDragOptions").RowDragOptions<T>;
+    get grid(): import("..").DataGrid<T>;
+    dispose(): void;
+    /** A press on a row: a drag may start once the pointer moves far enough. Returns whether it is watched. */
+    press(e: PointerEvent): boolean;
+    /** A key on a row: Ctrl+Shift+Up / Down (`moveUpKeys`, `moveDownKeys`) move it a place. Returns whether it was one. */
+    onKey(e: KeyboardEvent, index: number): boolean;
+    /**
+     * Moves grid row `fromIndex` to `toIndex` as a drop there would: `onDragStart`, `onDragChange`
+     * and `onDragEnd` (any of them can cancel it), then `onReorder`, which moves the data. The row
+     * stays the active one. Resolves to whether `onReorder` was raised.
+     */
+    move(fromIndex: number, toIndex: number, event?: Event): Promise<boolean>;
+    private onMove;
+    private onUp;
+    /** The drag passed the threshold: `onDragStart`, then the copy and the marks. Returns whether it goes on. */
+    private start;
+    /** The pointer moved while dragging: the copy follows, the grid under it shows the place, the rows scroll near the edges. */
+    private track;
+    /** Ends the drag: drops when `drop` and the place takes it, then clears the copy and the marks. */
+    private end;
+    /** The drop: `onReorder` here, or `onRemove` here and `onAdd` on the grid it went to. Returns their promises. */
+    private drop;
+    /** The arguments of an event of this grid's handlers about the dragged row; `from` is the grid it comes from. */
+    private args;
+    /** Raises a cancelable handler; whether it may go on. */
+    private ask;
+    private tell;
+    /** Where a row dragged to the point would land in a grid of the drag (this one, or one of its group), or `null`. */
+    private aimAt;
+    /** Where a row dragged to `y` would land among this grid's rows; `source` is the drag when it comes from this grid. */
+    private placeAt;
+    /** Draws the marks of every grid of the drag: the place it would land, the room made for it, the row it came from. */
+    private paint;
+    /** Shows where a row would land in this grid (`aim`), and, while it comes from here, where it was. */
+    private markAim;
+    /** How far the dragged row moves to stand at the place it would land: to the bottom (`down`) or the top of the row there. */
+    private offsetBetween;
+    private clearMarks;
+    /** Scrolls the grid under the pointer (or this one) while the pointer is near its top or bottom edge, frame by frame. */
+    private autoScroll;
+    /** The height of the sticky header over the rows. */
+    private headHeight;
+    /** The point kept inside `boundary`. */
+    private clamp;
+    /** The copy of the row (or the drag template) under the pointer. */
+    private showGhost;
+    /** `cursorOffset` as `{ x, y }`, or `null` when it is not given. */
+    private cursorOffset;
+    /** The data row at grid index `i`, `undefined` for a group row, a footer, a new row or one still loading. */
+    dataRowAt(i: number): T | undefined;
+    private keyOf;
+    /** The next data row from `i` in direction `dir` among the reachable rows, or -1. */
+    private nextDataRow;
+    private announceMove;
+    /** After the data moved the row, it stays the active row where it is now. */
+    private follow;
+}

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

@@ -0,0 +1,28 @@
+import { Component } from '@motifx/core';
+import type { GridModel } from '../model/GridModel';
+/**
+ * The row of totals under the rows: a cell per column, holding the items of `summary.totalItems`
+ * that show under it, one under the other. It stays at the bottom of the viewport while the rows
+ * scroll, and moves sideways with the columns (sticky columns stay). A stop of its own in the Tab
+ * order (`totalSummaryTabStop`), after the rows. It follows nothing: it draws itself again whenever the grid tells a
+ * change, and writes its cells (and tells `rowPrepared`) only when what they show changed.
+ */
+export declare class TotalRow<T> extends Component<HTMLDivElement> {
+    private readonly grid;
+    /** Cell elements by field. */
+    readonly cells: Map<string, HTMLDivElement>;
+    /** What the cells show, as last written: `''` writes them again. */
+    private drawnKey;
+    constructor(grid: GridModel<T>);
+    onConfigured(): void;
+    /** Writes the items again (`grid.repaint()`). */
+    redraw(): void;
+    /** A column's cell (one added at run time too; placed by the next `arrange`). */
+    addColumn(field: string): void;
+    private makeCell;
+    removeColumn(field: string): void;
+    /** Puts the cells in display order and numbers the visible ones; while columns are virtual, only the columns drawn have their cell in the row. */
+    arrange(visible: string[]): void;
+    /** Draws the row as the grid is now: its place and state, and the cells when what they show changed. */
+    draw(): void;
+}

package/dist/components/datagrid/view/action-button.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedAction } from './resolved-action';
+/** What a button shows: the action, its text and its look. Equal keys draw the same button. */
+export declare function actionKey<T>(a: ResolvedAction<T>): string;
+/**
+ * A button of a row's actions: a plain element with the kit button's classes (ghost, small), so a
+ * row costs no component. Disabled buttons stay focusable (`aria-disabled`) for the arrow keys.
+ */
+export declare function createActionButton(): HTMLButtonElement;
+/** Shows an action on a button; the content is built again only when the action or its text changes. */
+export declare function fillActionButton<T>(button: HTMLButtonElement, a: ResolvedAction<T>): void;

package/dist/components/datagrid/view/adaptive-form-host.d.ts

@@ -0,0 +1,8 @@
+import type { EditFormHost } from './edit-form-host';
+/** What a row's adaptive detail asks of the grid, besides what an edit form does. */
+export interface AdaptiveFormHost<T> extends EditFormHost<T> {
+    /** One of its editors took focus: the row becomes the one being edited. */
+    begin(): void;
+    /** A field was left, its value written into the row's draft. */
+    kept(field: string): void;
+}

package/dist/components/datagrid/view/check-mark.d.ts

@@ -0,0 +1,4 @@
+/** A check box drawn as plain DOM (`role="checkbox"`) for the selection column; the cell holds focus, not the box. */
+export declare function createCheck(label: string): HTMLSpanElement;
+/** Shows a state on a check box; only what changed is written. */
+export declare function setCheck(box: HTMLElement, state: boolean | 'mixed', label: string, enabled?: boolean): void;

package/dist/components/datagrid/view/column-node.d.ts

@@ -0,0 +1,7 @@
+/** A column or band in the column chooser's tree. */
+export interface ColumnNode {
+    id: string;
+    text: string;
+    enabled: boolean;
+    children?: ColumnNode[];
+}

package/dist/components/datagrid/view/detail-host.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentBase } from '@motifx/core';
+import type { DataGrid } from '../DataGrid';
+/** What a row's details ask of the grid. */
+export interface DetailHost<T> {
+    /** Holds the details' components, so they live and go with it. */
+    readonly owner: ComponentBase;
+    readonly grid: DataGrid<T>;
+    /** Closes a row's details by its key, as the user would. */
+    collapse(key: unknown): boolean;
+    /** What a row's adaptive detail holds. */
+    adaptiveContent(rowId: string, row: T): ComponentBase;
+}

package/dist/components/datagrid/view/drag-handle.d.ts

@@ -0,0 +1,2 @@
+/** The drag icon of a row (`rowDragging.showDragIcons`): plain DOM, the cell holds focus and the name. */
+export declare function createDragHandle(): HTMLSpanElement;

package/dist/components/datagrid/view/drag-select-host.d.ts

@@ -0,0 +1,20 @@
+/** What selecting by dragging asks of the grid it works in. */
+export interface DragSelectHost {
+    /** The grid's own element. */
+    root(): HTMLElement;
+    viewport(): HTMLElement | null;
+    /** The header cell of a column, to find the column under the pointer. */
+    headerCell(field: string): HTMLElement | undefined;
+    isRtl(): boolean;
+    /** The rows scrolled sideways: virtual columns follow. */
+    columnsScrolled(): void;
+    /**
+     * A drag passed the threshold on grid row `index`, column `field`: rows from there (`how` the keys
+     * held said), or a range from that cell. Returns whether it goes on.
+     */
+    begin(kind: 'rows' | 'cells', index: number, field: string, how: 'replace' | 'add' | 'extend' | 'paint'): boolean;
+    /** The pointer is over grid row `index`, column `field` now. */
+    reach(kind: 'rows' | 'cells', index: number, field: string): void;
+    /** The drag ended; `kept` false when Escape gave it up. */
+    finish(kind: 'rows' | 'cells', kept: boolean): void;
+}

package/dist/components/datagrid/view/drop-place.d.ts

@@ -0,0 +1,16 @@
+/** Where a dragged column or band lands among its neighbours, and where the mark between them goes. */
+export interface DropPlace {
+    /** Its place among them after the drop. */
+    target: number;
+    /** The x of the boundary it would land on, or `null` when it would stay where it is. */
+    x: number | null;
+}
+/**
+ * The place a column or band dragged to `x` lands: the number of neighbours whose centre lies
+ * before the pointer, kept within `lo`…`hi`. `rects` are the neighbours on the screen, the dragged
+ * one at `from` among them.
+ */
+export declare function dropPlace(rects: readonly {
+    left: number;
+    right: number;
+}[], from: number, lo: number, hi: number, x: number, rtl: boolean): DropPlace;

package/dist/components/datagrid/view/edit-form-host.d.ts

@@ -0,0 +1,11 @@
+import type { data } from '@motifx-community/data';
+import type { CellEditor } from './CellEditor';
+/** What the edit form asks of the grid. */
+export interface EditFormHost<T> {
+    save(): void;
+    cancel(): void;
+    /** `onEditorPreparing`: whether the editor may be made, with these props. `row` is the row itself, `entered` the values entered and not saved yet. */
+    prepare(field: string, row: T, entered: data.RowCheckContext<T>, isNew: boolean, options: Record<string, unknown>): boolean;
+    /** `onEditorPrepared`. */
+    prepared(field: string, row: T, entered: data.RowCheckContext<T>, isNew: boolean, editor: CellEditor<T>): void;
+}

package/dist/components/datagrid/view/editor-host.d.ts

@@ -0,0 +1,7 @@
+/** What an editor reports back to the grid. */
+export interface EditorHost {
+    /** Keep the value and close (a custom editor's `commit()`). */
+    commit(): void;
+    /** Close without keeping the value (a custom editor's `cancel()`). */
+    cancel(): void;
+}

package/dist/components/datagrid/view/editor-kind.d.ts

@@ -0,0 +1,2 @@
+/** Which editor a cell gets: by the column type, a lookup's, or the column's own. */
+export type EditorKind = 'text' | 'number' | 'date' | 'boolean' | 'list' | 'lookup' | 'custom';

package/dist/components/datagrid/view/editor-value.d.ts

@@ -0,0 +1,8 @@
+/** What an editor holds: a value, or the message of text it cannot read. */
+export type EditorValue = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/components/datagrid/view/expand-button.d.ts

@@ -0,0 +1,4 @@
+/** The arrow of the expand column, drawn as plain DOM (`role="button"`, `aria-expanded`); the cell holds focus, not the arrow. */
+export declare function createExpandButton(label: string): HTMLSpanElement;
+/** Shows a row's details state on its arrow (hidden for a row without details); only what changed is written. */
+export declare function setExpandButton(button: HTMLElement, shown: boolean, open: boolean, label: string, controls: string | null): void;

package/dist/components/datagrid/view/export-command.d.ts

@@ -0,0 +1,8 @@
+/** A command of the toolbar's export button: "Export all data to Excel", "Export selected rows to CSV". */
+export interface ExportCommand {
+    text: string;
+    format: string;
+    selected: boolean;
+    enabled: boolean;
+    run(): void;
+}

package/dist/components/datagrid/view/export-values.d.ts

@@ -0,0 +1,7 @@
+import type { GridExportTexts } from '../grid-export-texts';
+/** The `export` prop as the grid reads it: values, not functions. */
+export interface ExportValues {
+    formats: readonly string[] | undefined;
+    allowExportSelectedData: boolean | undefined;
+    texts: GridExportTexts | undefined;
+}

package/dist/components/datagrid/view/filter-builder-window-host.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentBase } from '@motifx/core';
+import type { GridFilterBuilderOptions } from '../grid-filter-builder-options';
+import type { Switches } from '../model/Switches';
+import type { PopupValues } from './popup-values';
+/** What the filter builder's window needs from the grid. */
+export interface FilterBuilderWindowHost {
+    /** The window is shown modal over it and goes with it. */
+    owner: ComponentBase;
+    /** The builder's props, live. */
+    options: GridFilterBuilderOptions;
+    /** The window's options. */
+    popup: Switches<PopupValues>;
+    /** Focus goes back here when the window closes and nothing else has it. */
+    returnFocus(): void;
+}

package/dist/components/datagrid/view/filter-panel-host.d.ts

@@ -0,0 +1,8 @@
+/** What the filter panel asks the grid. */
+export interface FilterPanelHost {
+    /** The filter value as one line of text; `''` without one. Reactive. */
+    text(): string;
+    openBuilder(): void;
+    clear(): void;
+    setEnabled(on: boolean): void;
+}

package/dist/components/datagrid/view/form-values.d.ts

@@ -0,0 +1,9 @@
+import type { FieldLabelMode } from '../../../parts/field/field-label-mode';
+import type { FormItem } from '../../formlayout/form-item';
+/** The edit form's options as the grid reads them: values, not functions. */
+export interface FormValues {
+    items: readonly (string | FormItem)[] | undefined;
+    colCount: number;
+    minColWidth: string | undefined;
+    labelMode: FieldLabelMode;
+}

package/dist/components/datagrid/view/ghost-target.d.ts

@@ -0,0 +1,2 @@
+/** What dropping a dragged header or chip would do where the pointer is. */
+export type GhostTarget = 'group' | 'move' | 'ungroup' | 'none';

package/dist/components/datagrid/view/group-panel-host.d.ts

@@ -0,0 +1,15 @@
+import type { DragGhost } from '../../../parts/drag/DragGhost';
+/** What the group panel asks the grid: the headers it drops chips on, and where focus goes. */
+export interface GroupPanelHost {
+    isRtl(): boolean;
+    /** The picture that follows a dragged chip. */
+    readonly ghost: DragGhost;
+    /** Marks where a chip dragged over the headers lands (NaN hides the mark); whether the point is over them. */
+    showHeaderDrop(field: string, x: number, y: number): boolean;
+    /** A chip was dropped on the headers at `x`: the column is ungrouped and put there. */
+    dropOnHeaders(field: string, x: number): void;
+    /** The last chip went away: focus goes back to the rows. */
+    focusRows(): void;
+    /** A key on a chip, before the panel handles it: `false` when the app takes it (`onKeyHandling`). */
+    keyHandling(e: KeyboardEvent): boolean;
+}

package/dist/components/datagrid/view/header-host.d.ts

@@ -0,0 +1,24 @@
+import type { DragGhost } from '../../../parts/drag/DragGhost';
+import type { GroupPanel } from './GroupPanel';
+/** What the header and the column menu ask the grid to do; the grid owns menus, focus and measuring. */
+export interface HeaderHost {
+    /** Whether the column has a menu (the feature is on and the menu would not be empty). */
+    hasMenu(field: string): boolean;
+    openMenu(field: string, anchor: HTMLElement): void;
+    autoSize(field: string): void;
+    autoSizeAll(): void;
+    startAdjust(kind: 'move' | 'resize', field: string): void;
+    isRtl(): boolean;
+    /** Opens the column's header filter next to `anchor`. */
+    openHeaderFilter(field: string, anchor: HTMLElement): void;
+    /** The header check box: select every row, or none. */
+    toggleAll(): void;
+    /** The state of the header check box. */
+    allState(): boolean | 'mixed';
+    /** The picture that follows a dragged header. */
+    readonly ghost: DragGhost;
+    /** The group panel while headers can be dropped on it, else `null`. */
+    groupTarget(): GroupPanel<any> | null;
+    /** Focus back to the active cell (after a menu changed which columns show). */
+    focusActive(): void;
+}

package/dist/components/datagrid/view/next-frame.d.ts

@@ -0,0 +1,4 @@
+/** Runs `fn` at the next frame (a short timeout where there are no frames); returns what stops it. */
+export declare function nextFrame(fn: () => void): number;
+/** Stops what `nextFrame` started; 0 is nothing. */
+export declare function stopFrame(id: number): void;

package/dist/components/datagrid/view/operator-texts.d.ts

@@ -0,0 +1,6 @@
+import type { UiStrings } from '../../../core/ui-strings';
+import type { GridFilterOperator } from '../grid-filter-operator';
+/** The name of each condition, in `uiLocale`. */
+export declare const OPERATOR_TEXTS: Record<GridFilterOperator, keyof UiStrings>;
+/** The short mark of each condition on its button. */
+export declare const OPERATOR_MARKS: Record<GridFilterOperator, string>;

package/dist/components/datagrid/view/pager-host.d.ts

@@ -0,0 +1,11 @@
+/** What the pager asks the grid: moves that leave an edited row first, the grid's name and its rows. */
+export interface PagerHost {
+    /** Goes to a page, 0-based. */
+    goTo(page: number): void;
+    /** Rows per page; 0: every row on one page. */
+    setPageSize(size: number): void;
+    /** The grid's accessible name. */
+    gridLabel(): string;
+    /** Data rows, saved new rows included. */
+    total(): number;
+}

package/dist/components/datagrid/view/place-in-order.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Puts the children of `parent` in the `desired` order, moving as few as possible and never the one
+ * that holds keyboard focus: moving a focused element in the DOM blurs it. Children not listed keep
+ * their place after the listed ones.
+ */
+export declare function placeInOrder(parent: Element, desired: readonly Element[]): void;

package/dist/components/datagrid/view/popup-values.d.ts

@@ -0,0 +1,12 @@
+/** The edit window's options as the grid reads them: values, not functions. */
+export interface PopupValues {
+    title: string | undefined;
+    showTitle: boolean;
+    width: number | string | undefined;
+    height: number | string | undefined;
+    resizable: boolean;
+    movable: boolean;
+    showCloseButton: boolean;
+    showMaximize: boolean;
+    fullScreen: boolean;
+}

package/dist/components/datagrid/view/resolved-action.d.ts

@@ -0,0 +1,16 @@
+import type { GridAction } from '../grid-action';
+import type { RowState } from '../row-state';
+/** An action as one row shows it now. */
+export interface ResolvedAction<T> {
+    action: GridAction<T>;
+    row: T;
+    state: RowState;
+    text: string;
+    /** Tooltip; `''` for none. */
+    hint: string;
+    disabled: boolean;
+    hasIcon: boolean;
+    showText: boolean;
+    /** In the "more" menu when it does not fit, always, or never. */
+    menu: 'auto' | 'always' | 'never';
+}

package/dist/components/datagrid/view/row-drag-host.d.ts

@@ -0,0 +1,14 @@
+import type { DataGrid } from '../DataGrid';
+import type { DragGhost } from '../../../parts/drag/DragGhost';
+/** What row dragging asks of the grid it works in. */
+export interface RowDragHost<T> {
+    readonly grid: DataGrid<T>;
+    readonly ghost: DragGhost;
+    /** The grid's own element. */
+    root(): HTMLElement;
+    viewport(): HTMLElement | null;
+    /** Makes grid row `index` the active row, focus along while the grid has it. */
+    focusRow(index: number): void;
+    /** The grid's accessible name. */
+    label(): string;
+}

package/dist/components/datagrid/view/row-drop-place.d.ts

@@ -0,0 +1,15 @@
+/** Where a dragged row lands among the rows under the pointer: before row `gap` (`rows.length`: after the last), or onto row `inside`. */
+export interface RowDropPlace {
+    gap: number;
+    /** The row dropped onto, or -1. */
+    inside: number;
+}
+/**
+ * The place a row dragged to `y` lands among `rows` (drawn rows, top to bottom): in the middle half
+ * of a row that takes drops (`canDropInside`) onto it, else before the row whose middle lies after
+ * the pointer. Above the first row is before it, below the last after it.
+ */
+export declare function rowDropPlace(rows: readonly {
+    top: number;
+    bottom: number;
+}[], y: number, canDropInside: (k: number) => boolean): RowDropPlace;

package/dist/components/datagrid/view/row-notices.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The notices (`GridNotices`) each part of a data row reads: when one of them is told, the rows drawn now draw that
+ * part again. Taken from what the parts read (the grid's state fields as `grid.` and the field); `settings` stands
+ * for every set of switches read, each told by its owner's name (`rowDrag`, `details`, `adaptive`, `columns`).
+ */
+export declare const ROW_LOOK: ReadonlySet<string>;
+export declare const ROW_CELLS: ReadonlySet<string>;
+export declare const ROW_RANGES: ReadonlySet<string>;
+/** The same for the parts of a group row, and for a group's footer row. */
+export declare const GROUP_LOOK: ReadonlySet<string>;
+export declare const GROUP_TEXT: ReadonlySet<string>;
+export declare const GROUP_SUMMARY: ReadonlySet<string>;
+export declare const GROUP_FOOTER: ReadonlySet<string>;
+export declare const ROW_ACTIONS: ReadonlySet<string>;

package/dist/components/datagrid/view/summary-cell.d.ts

@@ -0,0 +1,8 @@
+import type { SummaryPart } from '../model/summary-part';
+/**
+ * Writes summary items into a cell: one element per item, stacked, or on one line with `separator`
+ * between them. An item whose text does not name its column ("Sum: 1,234" under Amount) is read
+ * as one that does ("Sum of Amount: 1,234"): the shown text is hidden from assistive technology
+ * and the naming one is there, hidden from sight. Nothing is touched when the cell shows the same.
+ */
+export declare function fillSummaryCell(cell: HTMLElement, parts: readonly SummaryPart[], separator: string | null): void;

package/dist/components/datagrid/view/toolbar-host.d.ts

@@ -0,0 +1,32 @@
+import type { DataGrid } from '../DataGrid';
+import type { GridToolbarItem } from '../grid-toolbar-item';
+import type { GridToolbarItemName } from '../grid-toolbar-item-name';
+import type { ActionEntry } from '../model/action-entry';
+import type { ExportCommand } from './export-command';
+import type { GroupPanel } from './GroupPanel';
+/** What the toolbar asks the grid; the grid owns its data, menus and focus. */
+export interface ToolbarHost {
+    grid: DataGrid<any>;
+    /** Whether there is something to export (an exportable visible column). */
+    canExport(): boolean;
+    /** The commands of the export button: a format each, and each again for the selected rows when allowed. Reactive. */
+    exportCommands(): ExportCommand[];
+    /** The export button's name ("Export", or `export.texts.exportTo`). Reactive. */
+    exportName(): string;
+    /** Opens the list of columns under `anchor`. */
+    openColumns(anchor: HTMLElement): void;
+    /** Whether the list of columns has a column to show or hide. */
+    hasColumns(): boolean;
+    /** The group panel, which the toolbar holds while `groupPanel` is on. */
+    groupPanel(): GroupPanel<any>;
+    /** Id of the grid, for ids of the bar's own elements. */
+    gridId: string;
+    /** Whether actions can show in the toolbar (the `rowActions` item). Reactive. */
+    hasBarActions(): boolean;
+    /** The actions the toolbar shows now. Reactive. */
+    barEntries(): ActionEntry<any>[];
+    /** Runs an action of the bar on its rows. */
+    runBarAction(entry: ActionEntry<any>, location: 'toolbar'): void;
+    /** The items the bar takes, as `onToolbarPreparing` leaves them. */
+    prepare(items: readonly (GridToolbarItem | GridToolbarItemName)[]): readonly (GridToolbarItem | GridToolbarItemName)[];
+}