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

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

@@ -0,0 +1,42 @@
+import type { ClipboardContent } from './clipboard-content';
+import type { GridModel } from './GridModel';
+import type { PasteResult } from './paste-result';
+/**
+ * Copy and paste of the grid's cells. Copying takes the cell ranges, the active cell, or the
+ * selected rows of a multiple selection in the grid's order, with the copyable visible columns;
+ * pasting reads tab-separated lines into the cells the user can fill, from a cell rightwards and
+ * downwards (or one value into every cell of the ranges), through the rows' drafts and their checks.
+ */
+export declare class GridClipboard<T> {
+    private readonly model;
+    constructor(model: GridModel<T>);
+    /** Fields Ctrl+C copies, in display order (those the width hides too). */
+    fields(): string[];
+    /** What Ctrl+C copies now; `'all'` when every row of a server's filter is selected (that is for an export), `null` when there is nothing. */
+    copy(): ClipboardContent | 'all' | null;
+    /**
+     * What Ctrl+C copies of the cell ranges: the rows and the copyable columns they cover, in the grid's
+     * order, a cell outside every range left empty. `'unloaded'` while a row of them is still loading
+     * (that is for an export), `null` when there is nothing.
+     */
+    copyRanges(): ClipboardContent | 'unloaded' | null;
+    /** Writes one pasted text into every cell of the ranges the user can fill (rows still loading are left out). */
+    fill(text: string): PasteResult;
+    /**
+     * Writes tab-separated text into grid row `i` and the rows below it, from `field` rightwards. A
+     * cell the user cannot fill keeps its value; text that cannot be read leaves a message. Lines past
+     * the last row open new rows when `pasteNewRows` (and `addRows`) allow; a row not loaded yet ends
+     * the paste.
+     */
+    paste(text: string, i: number, field: string): PasteResult;
+    /** Reads a pasted text as the column's value into grid row `r`'s draft; a text that cannot be read leaves a message. */
+    private write;
+    /** The text of one cell as Ctrl+C copies it: what it shows, or its value (`copyValues`). */
+    cellText(row: T, field: string): string;
+    /** Pasted text of a lookup cell read as a key: exactly one item of the source must have that text. */
+    private lookupKey;
+    /** The selected rows in the grid's order; `null` without a multiple selection, `'all'` for "all" over data that loads in parts. */
+    private selectedRows;
+    /** A new row for a pasted line past the last row, right after grid row `last`; -1 when the settings or the place do not allow one. */
+    private openRow;
+}

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

@@ -0,0 +1,193 @@
+import { data } from '@motifx-community/data';
+import type { GridChanges } from '../grid-changes';
+import type { GridDataOptions } from './grid-data-options';
+import type { GroupLevel } from './group-level';
+import type { GroupNode } from './group-node';
+import { GroupView } from './GroupView';
+/**
+ * The rows the grid shows and their unsaved changes: a `DataSource` (all rows, a page, or blocks
+ * where the view is) and a `ChangeTracker` over it, read the way the grid numbers its rows.
+ *
+ * - `'all'`: the rows in order; saved new rows the grid still shows where they were entered (the
+ *   tracker keeps them until a reload) are left out of them, matched by key, so no row shows twice.
+ * - `'page'`: the loaded page; while another page loads its rows are not known yet.
+ * - `'blocks'`: what is loaded where the view is.
+ *
+ * Grouped, the places are those of the grouped list (`GroupView`): group rows and, in open groups,
+ * data rows. An adapter that groups, under blocks, gives the groups (keys and counts) and the blocks
+ * come in group order, so only what the view shows is loaded; otherwise every matching row is here
+ * and grouped in memory, as with rows in memory.
+ *
+ * Infinite, the places shown end where the parts loaded so far end: blocks load part by part from
+ * the start (the end is known when a part comes back short), anything else (rows in memory, groups)
+ * shows `pageSize` more places at a time.
+ */
+export declare class GridData<T> {
+    readonly source: data.DataSource<T, unknown>;
+    readonly tracker: data.ChangeTracker<T, unknown>;
+    readonly paged: boolean;
+    readonly infinite: boolean;
+    private readonly state;
+    private readonly owned;
+    private readonly expanded;
+    private readonly footers;
+    private readonly groupSummary;
+    private readonly locale;
+    private readonly subscriptions;
+    /** Rows of a page; 0: every row on one page. */
+    private size;
+    /** `'all'`: the rows without the saved new rows, and those rows' keys; dropped when either side changes. */
+    private shownRows;
+    private savedKeys;
+    /** The sort the grid gives; grouped on a server, the source sorts by the groups first. */
+    private userSort;
+    private sourceStatus;
+    private levels;
+    /** Who groups (`remoteGrouping`), and rows per request while every row loads for memory. */
+    private remote;
+    private loadSize;
+    /** How the rows are grouped: by the source's adapter (`'server'`), in memory, or not at all. */
+    private groupMode;
+    private groupState;
+    private groupGeneration;
+    private groupController;
+    private tree;
+    private view;
+    /** Memory: the rows in group order, and whether they must be grouped again. */
+    private grouped;
+    private groupedIndex;
+    private regroup;
+    /** Memory over pages or blocks: every matching row, loaded apart. */
+    private allRows;
+    private allIndex;
+    /** Every matching row of pages or blocks, loading or loaded, for grouping and summaries alike; dropped with the row set. */
+    private everyLoad;
+    private everyController;
+    /** Infinite: places shown; the first place of the part loading (-1: none), and whether it failed. */
+    private reach;
+    private part;
+    private failed;
+    /** Infinite over blocks: the places the view asked for last. */
+    private shown;
+    private readonly partLoaded;
+    /** Tells that fields of `state` changed (the grid tells its views). */
+    private readonly changed;
+    constructor(options: GridDataOptions<T>);
+    /** Rows of a page in paged mode; 0: every row on one page. */
+    get pageSize(): number;
+    /** Another page size; a source that loads pages drops its rows and loads its first page in it. */
+    setPageSize(size: number): void;
+    /** The page the source is on (`'page'`). */
+    get sourcePage(): number;
+    /** The sort the grid gave (without the groups). */
+    get sort(): readonly data.SortItem[];
+    /** Places in the list: data rows, and group rows while grouped; 0 while the first answer is loading. Infinite: the places shown so far. Reactive. */
+    get total(): number;
+    /** Infinite: whether every place shows (the end is known and reached); always `true` otherwise. Reactive. */
+    get ended(): boolean;
+    /** Infinite: a part after the first is loading. Reactive. */
+    get loadingMore(): boolean;
+    /** Infinite: the part loading failed; `retry()` loads it again. Reactive. */
+    get moreFailed(): boolean;
+    /** Data rows matching the query when they are known: rows in memory and groups always, blocks once counted or their end is reached. Reactive. */
+    get knownCount(): number | undefined;
+    /** Infinite: shows the next part, `pageSize` more places; blocks load it first. `false` while a part loads or every place shows. */
+    loadMore(): boolean;
+    /** Places of every row (and group row), loaded or not. */
+    private allPlaces;
+    /** Infinite over blocks, not grouped: each part waits for its block. */
+    private get byParts();
+    /** Infinite: back to the first part (a new query, other groups). */
+    private startOver;
+    /** Infinite over blocks: the part loading came (or failed), and the places shown grow. */
+    private takePart;
+    /** Infinite over blocks: asks for the places in view and the part loading. */
+    private ensureParts;
+    /** Data rows, in every group too. Reactive. */
+    get rowCount(): number;
+    /** Whether the rows are grouped now. */
+    get isGrouped(): boolean;
+    /** The data row at place `index`, or `undefined` while it is not loaded (or a group row or footer is there). */
+    rowAt(index: number): T | undefined;
+    /** A data row by its index among the rows in group order (grouped); `undefined` while it is not loaded. */
+    rowOfData(d: number): T | undefined;
+    /** The group whose row is at place `index`, or `null`. */
+    groupAt(index: number): GroupNode | null;
+    /** The group whose footer row is at place `index`, or `null`. */
+    footerAt(index: number): GroupNode | null;
+    /** The grouped list, while grouped and known. */
+    groupView(): GroupView | null;
+    /** Memory: the rows in group order; `null` when a server groups them. */
+    groupedRows(): readonly T[] | null;
+    /** Memory: the rows of a group, levels below included; `null` when a server groups them. */
+    rowsOfGroup(node: GroupNode): T[] | null;
+    /** Whether a server groups the rows (its groups carry the summaries it was asked for). */
+    get groupedOnServer(): boolean;
+    /**
+     * Every matching row of a source that loads pages or blocks, asked for once per row set (`size`
+     * rows a request, 0 all at once) and kept until the filter, the search or the rows change. Grouping
+     * and summaries in memory share it.
+     */
+    everyRow(size: number): Promise<T[]>;
+    /** The view shows places `first` to `end - 1`: blocks load what is missing; `immediate` skips the wait after a jump. */
+    ensure(first: number, end: number, immediate: boolean): void;
+    /** Keeps the block of the row at place `index` loaded; -1 lets it go. */
+    pin(index: number): void;
+    setPage(page: number): void;
+    setSort(sort: readonly data.SortItem[]): void;
+    setFilter(filter: data.FilterExpression | null): void;
+    /**
+     * Groups the rows by these levels (none: not grouped), with `sort` inside the groups. Under blocks,
+     * the source's adapter groups when every level has a field it can group by and `remote` says so
+     * (`'auto'`: when the adapter groups); anything else is grouped in memory, from every matching row
+     * (`loadSize` a request, 0 all at once).
+     */
+    setGrouping(levels: readonly GroupLevel[], options?: {
+        sort?: readonly data.SortItem[];
+        remote?: 'auto' | boolean;
+        loadSize?: number;
+    }): void;
+    /** The open groups changed: the list is made again. */
+    regroupView(): void;
+    /** Loads again, keeping the position; saved new rows leave where they were entered and take their place among the rows. */
+    refresh(): void;
+    retry(): void;
+    /** Place of a data row, found by its key; -1 when it is not loaded or a collapsed group hides it. */
+    indexOfRow(row: T): number;
+    private placeOf;
+    /** Index of a data row among the rows in group order (grouped), found by its key; -1 when it is not loaded. */
+    dataIndexOf(row: T): number;
+    /** Whether the rows the grid holds have this row (by key). */
+    hasLoaded(row: T): boolean;
+    /** The row with this key among the rows the grid holds and the source's. */
+    rowByKey(key: unknown): T | undefined;
+    /** Every row the grid holds now: all of them in memory, the page, or the blocks loaded. */
+    forEachLoaded(fn: (row: T) => void): void;
+    /** The id the tracker keeps a row under: its key as text, or `+1`, `+2` … for a new row. */
+    idOf(row: T): string;
+    /** What the tracker keeps of a row, by id. */
+    edit(rowId: string | undefined): data.RowEditState<T> | undefined;
+    /** The unsaved changes: the rows themselves, with the changed values beside them. */
+    changes(): GridChanges<T>;
+    dispose(): void;
+    private keyIdOf;
+    /** The sort the source gets: grouped on a server, the groups' fields come first. */
+    private sourceSort;
+    /** Keys of the saved new rows the tracker still keeps where they were entered. */
+    private saved;
+    private rows;
+    private allByKey;
+    private rowsChanged;
+    private updateStatus;
+    private sourceChanged;
+    private reloadGroups;
+    /** A server's groups: keys and counts of every level, and their summaries, no rows. */
+    private loadGroups;
+    /** Every matching row, to group in memory (an adapter that cannot group, or a value only memory reads). */
+    private loadEveryRow;
+    private startGroupLoad;
+    private stopGroupLoad;
+    private dropEveryRow;
+    /** Groups the rows in memory: the source's rows, or every matching row loaded apart. */
+    private groupInMemory;
+}

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

@@ -0,0 +1,157 @@
+import { Emitter, type EventArgs, type Event as MotifEvent } from '@motifx/core';
+import type { GridActionRanEventArgs } from '../grid-action-ran-event-args';
+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 { GridActionRunningEventArgs } from '../grid-action-running-event-args';
+import type { GridCellClickEventArgs } from '../grid-cell-click-event-args';
+import type { GridCellSelectionChangedEventArgs } from '../grid-cell-selection-changed-event-args';
+import type { GridCellSelectionChangingEventArgs } from '../grid-cell-selection-changing-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 { GridEditorPreparedEventArgs } from '../grid-editor-prepared-event-args';
+import type { GridEditorPreparingEventArgs } from '../grid-editor-preparing-event-args';
+import type { GridExportedEventArgs } from '../grid-exported-event-args';
+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 { 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 { 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 { 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 { GridInitNewRowEventArgs } from '../grid-init-new-row-event-args';
+import type { GridKeyHandlingEventArgs } from '../grid-key-handling-event-args';
+import type { GridLayout } from '../grid-layout';
+import type { GridLayoutChangingEventArgs } from '../grid-layout-changing-event-args';
+import type { GridMoreRowsLoadedEventArgs } from '../grid-more-rows-loaded-event-args';
+import type { GridMoreRowsLoadingEventArgs } from '../grid-more-rows-loading-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 { GridRowExpandedEventArgs } from '../grid-row-expanded-event-args';
+import type { GridRowExpandingEventArgs } from '../grid-row-expanding-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 { GridRowValidatingEventArgs } from '../grid-row-validating-event-args';
+import type { GridSavedEventArgs } from '../grid-saved-event-args';
+import type { GridSavingEventArgs } from '../grid-saving-event-args';
+import type { GridSearchTextChangedEventArgs } from '../grid-search-text-changed-event-args';
+import type { GridSearchTextChangingEventArgs } from '../grid-search-text-changing-event-args';
+import type { GridSelectionChangedEventArgs } from '../grid-selection-changed-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 { GridSummaryChangedEventArgs } from '../grid-summary-changed-event-args';
+import type { GridToolbarPreparingEventArgs } from '../grid-toolbar-preparing-event-args';
+/**
+ * Every event of the grid, by name: `grid.onX` is `events.x.event`, the `onX` prop listens to it.
+ * Each event counts its listeners, so the grid skips the work of one nobody listens to (a row
+ * drawn while scrolling).
+ */
+export declare class GridEvents<T> {
+    readonly selectionChanging: Emitter<GridSelectionChangingEventArgs>;
+    readonly selectionChanged: Emitter<GridSelectionChangedEventArgs>;
+    readonly cellSelectionChanging: Emitter<GridCellSelectionChangingEventArgs>;
+    readonly cellSelectionChanged: Emitter<GridCellSelectionChangedEventArgs>;
+    readonly editorPreparing: Emitter<GridEditorPreparingEventArgs<T>>;
+    readonly editorPrepared: Emitter<GridEditorPreparedEventArgs<T>>;
+    readonly rowValidating: Emitter<GridRowValidatingEventArgs<T>>;
+    readonly searchTextChanging: Emitter<GridSearchTextChangingEventArgs>;
+    readonly searchTextChanged: Emitter<GridSearchTextChangedEventArgs>;
+    readonly rowExpanding: Emitter<GridRowExpandingEventArgs>;
+    readonly rowExpanded: Emitter<GridRowExpandedEventArgs>;
+    readonly rowCollapsing: Emitter<GridRowExpandingEventArgs>;
+    readonly rowCollapsed: Emitter<GridRowExpandedEventArgs>;
+    readonly groupingChanging: Emitter<GridGroupingChangingEventArgs>;
+    readonly groupingChanged: Emitter<GridGroupingChangedEventArgs>;
+    readonly groupDropping: Emitter<GridGroupDroppingEventArgs>;
+    readonly cellClick: Emitter<GridCellClickEventArgs<T>>;
+    readonly cellDblClick: Emitter<GridCellClickEventArgs<T>>;
+    readonly rowClick: Emitter<GridRowClickEventArgs<T>>;
+    readonly rowDblClick: Emitter<GridRowClickEventArgs<T>>;
+    readonly cellPrepared: Emitter<GridCellPreparedEventArgs<T>>;
+    readonly rowPrepared: Emitter<GridRowPreparedEventArgs<T>>;
+    readonly contentReady: Emitter<GridContentReadyEventArgs>;
+    readonly dataErrorOccurred: Emitter<GridDataErrorEventArgs<T>>;
+    readonly editingStart: Emitter<GridEditingStartEventArgs<T>>;
+    readonly initNewRow: Emitter<GridInitNewRowEventArgs<T>>;
+    readonly rowInserting: Emitter<GridRowInsertingEventArgs<T>>;
+    readonly rowInserted: Emitter<GridRowInsertedEventArgs<T, unknown>>;
+    readonly rowUpdating: Emitter<GridRowUpdatingEventArgs<T, unknown>>;
+    readonly rowUpdated: Emitter<GridRowUpdatedEventArgs<T, unknown>>;
+    readonly rowRemoving: Emitter<GridRowRemovingEventArgs<T, unknown>>;
+    readonly rowRemoved: Emitter<GridRowRemovedEventArgs<T, unknown>>;
+    readonly saving: Emitter<GridSavingEventArgs<T>>;
+    readonly saved: Emitter<GridSavedEventArgs<T>>;
+    readonly editCanceling: Emitter<GridEditCancelingEventArgs<T>>;
+    readonly editCanceled: Emitter<GridEditCanceledEventArgs<T>>;
+    readonly focusedCellChanging: Emitter<GridFocusedCellChangingEventArgs<T>>;
+    readonly focusedCellChanged: Emitter<GridFocusedCellChangedEventArgs<T>>;
+    readonly focusedRowChanging: Emitter<GridFocusedRowChangingEventArgs<T>>;
+    readonly focusedRowChanged: Emitter<GridFocusedRowChangedEventArgs<T>>;
+    readonly keyHandling: Emitter<GridKeyHandlingEventArgs>;
+    readonly optionChanged: Emitter<GridOptionChangedEventArgs>;
+    readonly exporting: Emitter<GridExportingEventArgs>;
+    readonly exported: Emitter<GridExportedEventArgs>;
+    readonly contextMenuPreparing: Emitter<GridContextMenuPreparingEventArgs<T>>;
+    readonly toolbarPreparing: Emitter<GridToolbarPreparingEventArgs>;
+    readonly sortChanging: Emitter<GridSortChangingEventArgs>;
+    readonly sortChanged: Emitter<GridSortChangedEventArgs>;
+    readonly filterChanging: Emitter<GridFilterChangingEventArgs>;
+    readonly filterChanged: Emitter<GridFilterChangedEventArgs>;
+    readonly filterBuilderOpening: Emitter<GridFilterBuilderOpeningEventArgs>;
+    readonly filterBuilderOpened: Emitter<GridFilterBuilderOpenedEventArgs>;
+    readonly filterBuilderClosing: Emitter<GridFilterBuilderClosingEventArgs>;
+    readonly filterBuilderClosed: Emitter<GridFilterBuilderClosedEventArgs>;
+    readonly pageChanging: Emitter<GridPageChangingEventArgs>;
+    readonly pageChanged: Emitter<GridPageChangedEventArgs>;
+    readonly pageSizeChanging: Emitter<GridPageSizeChangingEventArgs>;
+    readonly pageSizeChanged: Emitter<GridPageSizeChangedEventArgs>;
+    readonly moreRowsLoading: Emitter<GridMoreRowsLoadingEventArgs>;
+    readonly moreRowsLoaded: Emitter<GridMoreRowsLoadedEventArgs>;
+    readonly layoutChanging: Emitter<GridLayoutChangingEventArgs>;
+    readonly layoutChanged: Emitter<GridLayout>;
+    readonly copying: Emitter<GridCopyingEventArgs>;
+    readonly pasting: Emitter<GridPastingEventArgs>;
+    readonly summaryChanged: Emitter<GridSummaryChangedEventArgs>;
+    readonly actionRunning: Emitter<GridActionRunningEventArgs<T>>;
+    readonly actionRan: Emitter<GridActionRanEventArgs<T>>;
+    readonly adaptiveDetailRowPreparing: Emitter<GridAdaptiveDetailRowPreparingEventArgs<T>>;
+    readonly adaptiveDetailRowExpanding: Emitter<GridAdaptiveRowExpandingEventArgs<T>>;
+    readonly adaptiveDetailRowExpanded: Emitter<GridAdaptiveRowExpandedEventArgs<T>>;
+    readonly adaptiveDetailRowCollapsing: Emitter<GridAdaptiveRowExpandingEventArgs<T>>;
+    readonly adaptiveDetailRowCollapsed: Emitter<GridAdaptiveRowExpandedEventArgs<T>>;
+    private readonly counts;
+    private readonly events;
+    /** The event of an emitter of this set, counting who listens. */
+    event<A>(emitter: Emitter<A>): MotifEvent<A>;
+    /** Whether someone listens to the emitter. */
+    listened(emitter: Emitter<any>): boolean;
+    /** Fires a cancelable event; whether it may go on (nobody listens, or nobody cancelled). */
+    ask<A extends EventArgs>(emitter: Emitter<A>, args: () => A): boolean;
+    /** Fires an event when someone listens; the args are made only then. */
+    tell<A>(emitter: Emitter<A>, args: () => A): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,70 @@
+import type { GridExportOptions } from '../grid-export-options';
+import type { GridSheet } from '../grid-sheet';
+import type { GridSheetOptions } from '../grid-sheet-options';
+import type { ExportTable } from './export-table';
+import type { GridModel } from './GridModel';
+/** What `sheet()` needs from the grid besides the options. */
+type SheetRun = GridSheetOptions & {
+    selected: boolean;
+    rtl: boolean;
+    widthOf: (field: string) => number;
+};
+/**
+ * The rows of an export: every row of the filter in the sort order, with the visible exportable
+ * columns in display order. Rows in memory are taken as they are; a server's come in parts through
+ * the data source (`loadRange`), so its own filter, search and sort apply. Cells read like the grid
+ * shows them, unsaved edits included; new rows not saved yet are not data and stay out. Grouped,
+ * the rows come in group order, every group open, and the CSV has a "Column: value" line per group.
+ * The summaries come as the grid shows them: group footers after their rows, the totals last. With
+ * bands, their titles come in rows above the columns' titles. Columns the width hides are exported.
+ */
+export declare class GridExport<T> {
+    private readonly model;
+    constructor(model: GridModel<T>);
+    fields(): string[];
+    /** The bands over the exported columns, a list per level from the top: each band and the columns it spans. */
+    bandRows(fields: readonly string[]): {
+        id: string;
+        title: string;
+        first: number;
+        count: number;
+    }[][];
+    table(options: GridExportOptions, signal: AbortSignal): Promise<ExportTable>;
+    /**
+     * The rows as a sheet of typed cells, for a file writer: numbers, dates and yes/no stay values;
+     * lookups, lists and columns with a `format` function are their texts; summaries are their texts,
+     * with their values beside them for `customizeCell`.
+     */
+    sheet(options: SheetRun, signal: AbortSignal): Promise<GridSheet<T>>;
+    /** The table as CSV text, for a spreadsheet: a byte order mark, the locale's separator, titles first. */
+    csv(table: ExportTable, options: GridExportOptions): string;
+    /**
+     * The header rows of a sheet, as DevExtreme's Excel export writes them: a row per level of bands,
+     * each band's title in the first cell it spans and merged over the rest; a column's title in the
+     * row under its deepest band, merged down to the last header row.
+     */
+    private headerRows;
+    /** The summary lines of a table as objects by field, in the order they come: footers after their rows, the totals last. */
+    summaryObjects(table: ExportTable): {
+        after: number;
+        values: Record<string, string>;
+    }[];
+    /** Summary items under their columns, as cells by field; several in a cell one per line. */
+    private cells;
+    /** The summary items that have a value, under each column, by field. */
+    private entries;
+    /** A group's line: "Column: value", its summary items after it, those aligned by column under their columns. */
+    private groupLine;
+    /** A group's row of a sheet: its text in the first cell, the items aligned by column under their columns. */
+    private groupRow;
+    /** The text of a group's line, the items in it, and the items under their columns. */
+    private groupParts;
+    /** Lookup cells and groups export their texts: every key of the rows is resolved first. */
+    private loadTexts;
+    /** Saves text as a file through a link the browser downloads. */
+    download(text: string, fileName: string): void;
+    private rows;
+    /** Selected rows that are loaded, when the key is not one field and the server cannot be asked for them. */
+    private loadedSelected;
+}
+export {};

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

@@ -0,0 +1,61 @@
+import { data } from '@motifx-community/data';
+import type { GridSettings } from '../grid-settings';
+import type { ColumnModel } from './ColumnModel';
+import type { GroupLevel } from './group-level';
+import type { GroupNode } from './group-node';
+import type { Switches } from './Switches';
+/**
+ * What the rows are grouped by, in order, and which groups are open. A level opens its groups by
+ * default as its column's `autoExpandGroup` says, else the grid's `autoExpandAll`; `expandAll` and
+ * `collapseAll` change that default for a level, and the groups opened or closed one by one are kept
+ * apart, by id, so they stay as they are while the rows load again. Reads are reactive.
+ */
+export declare class GridGroups<T> {
+    private readonly columns;
+    private readonly settings;
+    /** Called when the state changed (the grid tells its views). */
+    notify: ((name: string) => void) | null;
+    private tell;
+    readonly state: {
+        items: {
+            field: string;
+            dir?: 'asc' | 'desc';
+        }[];
+        version: number;
+    };
+    /** Groups opened or closed against their level's default, by id, with their level. */
+    private readonly toggled;
+    /** A level's default set by `expandAll` / `collapseAll`. */
+    private readonly levelDefaults;
+    constructor(columns: ColumnModel<T>, settings: Switches<GridSettings>);
+    get items(): data.GroupItem[];
+    get any(): boolean;
+    /** Grouped fields, in order. */
+    fields(): string[];
+    indexOf(field: string): number;
+    isGrouped(field: string): boolean;
+    dirOf(field: string): 'asc' | 'desc';
+    /** Whether the user may group by a column, and drag it to the group panel. */
+    canGroup(field: string): boolean;
+    /** Levels as they are kept: known data columns only, each once, with a direction. */
+    normalize(items: readonly data.GroupItem[]): data.GroupItem[];
+    /** Whether these levels are the ones now. */
+    same(items: readonly data.GroupItem[]): boolean;
+    /** Replaces the levels: known data columns only, each once. Returns whether they changed. */
+    set(items: readonly data.GroupItem[]): boolean;
+    /** The items with `field` at `index` (moved there if it is grouped already). */
+    withField(field: string, index: number, dir?: 'asc' | 'desc'): data.GroupItem[];
+    /** The items without `field`. */
+    without(field: string): data.GroupItem[];
+    /** The levels as the data needs them: the server's field and the reader of each. */
+    levels(): GroupLevel[];
+    isExpanded(node: GroupNode): boolean;
+    /** Opens or closes one group. Returns whether it changed. */
+    setExpanded(node: GroupNode, open: boolean): boolean;
+    /** Opens (or closes) every group of a level, or of every level. */
+    setAll(open: boolean, level?: number): void;
+    /** What the open state depends on, read so a watcher follows it. */
+    track(): string;
+    private levelDefault;
+    private changed;
+}