@box-kite/react 1.0.0 → 2.0.0

package/components/dataGrid/export/gridExport.d.ts

@@ -0,0 +1,10 @@
+import { default as XlsxUtils } from '../../../utils/export/xlsxUtils';
+import { DataGridCsvOptions, DataGridXlsxOptions, ExportTable } from '../contracts/dataGridContract';
+/** The grid as a worksheet: a bold header over frozen rows, then the table's own rows and their levels. */
+export declare function sheetOf(table: ExportTable, options?: DataGridXlsxOptions, name?: string): XlsxUtils.Sheet;
+/** The workbook's bytes, for a caller that wants to upload the file rather than save it. */
+export declare function xlsx(table: ExportTable, options?: DataGridXlsxOptions, name?: string): Uint8Array<ArrayBuffer>;
+/** The CSV text. Group rows are written where they sit; a file has no outline to collapse them into. */
+export declare function csv(table: ExportTable, options?: DataGridCsvOptions): string;
+export declare function downloadCsv(table: ExportTable, fileName: string, options?: DataGridCsvOptions): void;
+export declare function downloadXlsx(table: ExportTable, fileName: string, options?: DataGridXlsxOptions): void;

package/components/dataGrid/gridNavigationContext.d.ts

@@ -1,4 +1,5 @@
-import { RovingFocusItemProps } from '../../react/a11y/useRovingFocus';
+import { ChangeDetails } from '../../react/a11y/useControllableState';
+import { RovingFocusItemProps, RovingFocusReason } from '../../react/a11y/useRovingFocus';
 /**
  * The grid's keyboard coordinates, shared with every cell. Rows are numbered as `aria-rowindex` is —
  * headers, then the filter row, then the body — and a cell asks for its roving tabindex by that pair, so
@@ -13,6 +14,13 @@ export interface GridNavigation {
     headerRowCount: number;
     /** The roving tabindex and the ref for one cell, in the coordinates above. */
     cellProps: (row: number, column: number) => RovingFocusItemProps;
+    /**
+     * Move the tab stop to a cell without a keystroke having done it — what Tab out of an editor and into
+     * the next editable cell moves. `'programmatic'` rather than `'keyboard'` on purpose: a keyboard move
+     * focuses the cell from the navigation's own layout effect, which would take focus off an editor
+     * mounting under it.
+     */
+    setActiveCell: (row: number, column: number, details: ChangeDetails<RovingFocusReason>) => void;
 }
 /**
  * Absent outside a DataGrid, and absent on purpose: `DataGridCell` is rendered by the grid and by

package/components/dataGrid/models/aggregateCellModel.d.ts

@@ -0,0 +1,34 @@
+import { AggregateScope, AggregateValue } from '../contracts/dataGridContract';
+import { default as ColumnModel } from './columnModel';
+import { default as GridModel } from './gridModel';
+/**
+ * One aggregated cell: a column, the rows it covered, and the value that came out. The same model backs a
+ * group row's aggregate and the footer's, which is why `AggregateCell` is one renderer rather than two.
+ */
+export default class AggregateCellModel<TRow> {
+    readonly grid: GridModel<TRow>;
+    readonly column: ColumnModel<TRow>;
+    readonly rows: TRow[];
+    readonly scope: AggregateScope;
+    /**
+     * A total the grid was handed rather than one it works out. Read when it is *asked for*, not when this
+     * model is built: a server's group row arrives after the cell that shows it, and a value baked in at
+     * construction stayed empty for the life of the row (measured in Chrome 152).
+     */
+    private readonly given?;
+    constructor(grid: GridModel<TRow>, column: ColumnModel<TRow>, rows: TRow[], scope: AggregateScope, 
+    /**
+     * A total the grid was handed rather than one it works out. Read when it is *asked for*, not when this
+     * model is built: a server's group row arrives after the cell that shows it, and a value baked in at
+     * construction stayed empty for the life of the row (measured in Chrome 152).
+     */
+    given?: (() => AggregateValue | undefined) | undefined);
+    /** This column's value from every row in scope, in row order — what a custom aggregation is handed. */
+    private readonly _values;
+    get values(): unknown[];
+    private readonly _value;
+    get value(): AggregateValue;
+    get isExpanded(): boolean;
+    get isFirst(): boolean;
+    get isLast(): boolean;
+}

package/components/dataGrid/models/aggregationModel.d.ts

@@ -0,0 +1,32 @@
+import { AggregateValue, ColumnAggregate } from '../contracts/dataGridContract';
+import { default as AggregateCellModel } from './aggregateCellModel';
+import { default as ColumnModel } from './columnModel';
+import { default as GridModel } from './gridModel';
+/** Run a column's aggregation over one scope. An unknown name answers nothing rather than throwing. */
+export declare function aggregate<TRow>(fn: ColumnAggregate<TRow>, values: unknown[], rows: TRow[]): AggregateValue;
+/**
+ * Aggregation concern: which columns aggregate, and the footer they add up to. The arithmetic is in the
+ * built-ins above and the per-cell part is `AggregateCellModel` — this is what the grid answers once.
+ */
+export default class AggregationModel<TRow> {
+    readonly grid: GridModel<TRow>;
+    constructor(grid: GridModel<TRow>);
+    /** The visible columns carrying an aggregate, in column order. */
+    get columns(): ColumnModel<TRow>[];
+    /** Whether anything aggregates at all — what decides a group row shows values instead of one wide label. */
+    get hasAggregates(): boolean;
+    /** Whether the footer row is rendered: asked for, and with something to put in it. */
+    get hasFooter(): boolean;
+    /** What the footer's leading cell says. `footer: { label }` replaces it; an empty label drops it. */
+    get footerLabel(): React.ReactNode;
+    /**
+     * Which column the label goes in: the first one that holds data and has no aggregate of its own. A number
+     * wins its cell, and the row-number, selection and expander columns are too narrow to read a word in.
+     */
+    get footerLabelColumn(): ColumnModel<TRow> | undefined;
+    /**
+     * One cell per visible column, over every row the filters left — which is the page rather than the table
+     * when the server is paginating, since those are the only rows the grid has.
+     */
+    readonly footerCells: import('../../../utils/memo').Memo<AggregateCellModel<TRow>[]>;
+}

package/components/dataGrid/models/cellKeys.d.ts

@@ -0,0 +1,11 @@
+import { Key } from '../contracts/dataGridContract';
+/**
+ * The four columns the grid adds for itself, by the key each is found under. Their own module rather
+ * than `gridModel`'s, because a model that needs one of them would otherwise import the grid at load
+ * time — and `SourceGroupRowModel` extends `GroupRowModel` across exactly that cycle, which leaves the
+ * base class undefined depending on which file the bundler reached first.
+ */
+export declare const ROW_NUMBER_CELL_KEY: Key;
+export declare const ROW_SELECTION_CELL_KEY: Key;
+export declare const GROUPING_CELL_KEY: Key;
+export declare const ROW_DETAIL_CELL_KEY: Key;

package/components/dataGrid/models/cellModel.d.ts

@@ -1,3 +1,4 @@
+import { CellEditorConfig } from '../contracts/dataGridContract';
 import { default as ColumnModel } from './columnModel';
 import { default as GridModel } from './gridModel';
 import { default as RowModel } from './rowModel';
@@ -13,6 +14,31 @@ export default class CellModel<TRow> {
     get isLast(): boolean;
     /** Toggle this row's detail panel (used by the row-detail expand cell). */
     toggleDetail: () => void;
-    /** Toggle this row's selection (used by the row-selection checkbox cell). */
+    /** Whether the row is half-selected — a tree row whose subtree is partly ticked. */
+    get indeterminate(): boolean;
+    /** Toggle this row's selection (used by the row-selection checkbox cell). The row owns what that means. */
     toggleSelection: () => void;
+    /** Whether this cell can be edited at all — the column's answer about this row. */
+    get editable(): boolean;
+    /** Whether the editor is open on this cell. One cell at a time, grid-wide. */
+    get editing(): boolean;
+    /** Which editor this cell opens, resolved from the column or read off the value in it. */
+    get editor(): CellEditorConfig<TRow>;
+    /** What is in the open editor — the value a custom `EditCell` binds its control to. */
+    get draft(): unknown;
+    /** What the last commit was rejected with. The editor stays open until it is fixed or abandoned. */
+    get error(): string | undefined;
+    /** Whether an async `def.onCellEdit` has been asked about this cell and has not answered. */
+    get pending(): boolean;
+    /**
+     * Open the editor on this cell. `initial` is what a printable key pressed on the cell starts it with,
+     * replacing the value rather than being appended to it.
+     */
+    beginEdit: (initial?: string) => void;
+    /** Write a new draft into the open editor. */
+    setDraft: (value: unknown) => void;
+    /** Accept the draft, if `def.onCellEdit` lets it — what Enter does. */
+    commitEdit: () => void;
+    /** Close the editor with nothing written — what Escape does. */
+    cancelEdit: () => void;
 }

package/components/dataGrid/models/columnModel.d.ts

@@ -1,4 +1,4 @@
-import { ColumnFilterConfig, ColumnType, ContextMenuConfig, FilterValue, Key, NumberFilterValue, PinPosition, PinPositionInput, SortDirection } from '../contracts/dataGridContract';
+import { ColumnAggregate, ColumnEditable, ColumnFilterConfig, ColumnType, ContextMenuConfig, FilterValue, Key, NumberFilterValue, PinPosition, PinPositionInput, SortDirection } from '../contracts/dataGridContract';
 import { default as GridModel } from './gridModel';
 import { default as HeaderCellModel } from './headerCellModel';
 /** Discriminates the structural role of a column — replaces scattered `key === *_CELL_KEY` checks. */
@@ -52,7 +52,7 @@ export default class ColumnModel<TRow> {
     get isLastLeaf(): boolean;
     get key(): Key;
     get header(): string | undefined;
-    get align(): "left" | "right" | "center" | "end" | "start" | undefined;
+    get align(): "center" | "left" | "right" | "start" | "end" | undefined;
     /** End-aligned either way it is spelled — `right` is the physical name of `end` in a left-to-right grid. */
     get isEndAligned(): boolean;
     /** Whether an explicit `align` was provided (mirrors the original `'align' in def` check). */
@@ -61,6 +61,11 @@ export default class ColumnModel<TRow> {
     get Cell(): import('react').ComponentType<{
         cell: import('./cellModel').default<TRow>;
     }> | undefined;
+    /** This column's aggregation, if it has one — the thing that decides it appears on a group row at all. */
+    get aggregate(): ColumnAggregate<TRow> | undefined;
+    get AggregateCell(): import('react').ComponentType<{
+        cell: import('./aggregateCellModel').default<TRow>;
+    }> | undefined;
     get filterable(): boolean | ColumnFilterConfig | undefined;
     /** Resolved filter config, or undefined when this column isn't filterable. */
     get filterConfig(): ColumnFilterConfig | undefined;
@@ -75,6 +80,11 @@ export default class ColumnModel<TRow> {
     setNumberFilter(operator: NumberFilterValue['operator'], value: string | number, valueTo?: string | number): void;
     setMultiselectFilter(values: (string | number | boolean | null)[]): void;
     clearFilter(): void;
+    /**
+     * Whether this column can be edited: the column's own answer, or the grid-wide default it falls back
+     * to. A predicate is passed through as it stands — `EditModel` is what asks it about a row.
+     */
+    get editable(): ColumnEditable<TRow>;
     /** Whether sorting is enabled for this column. Column-level setting takes priority over grid-level. */
     get sortable(): boolean;
     /** Whether resizing is enabled for this column. Column-level setting takes priority over grid-level. */

package/components/dataGrid/models/dataSourceModel.d.ts

@@ -0,0 +1,177 @@
+import { DataSource, Key } from '../contracts/dataGridContract';
+import { default as DetailRowModel } from './detailRowModel';
+import { default as GridModel } from './gridModel';
+import { default as GroupRowModel } from './groupRowModel';
+import { default as RowModel } from './rowModel';
+import { BlockStatus } from './sourceLevel';
+export type { BlockStatus };
+/**
+ * The server row model: the grid asks `def.dataSource` for blocks and this holds them. Everything the
+ * grid would have done over `data` — filtering, sorting, paging, grouping — is a *request* here, so the
+ * browser never holds more than the blocks in play.
+ *
+ * Two invariants are worth naming. A response is only accepted while the query it was asked under is
+ * still the current one: `_query` is bumped by every sort, filter and grouping change, a request carries
+ * the value it was made at, and a late answer to an old question is dropped rather than written over a
+ * new one — which is the whole of the out-of-order problem an async row model has. And the cache is a
+ * *tree* of levels, one per open group: the rows the grid draws are a walk over it, so a group holds its
+ * children only while somebody has it open.
+ */
+export default class DataSourceModel<TRow> {
+    readonly grid: GridModel<TRow>;
+    constructor(grid: GridModel<TRow>);
+    /** The top level, and every open group's beside it — one entry per path somebody has opened. */
+    private root;
+    private levels;
+    /** Blocks in the order they were last wanted, level and index; the front of it is what eviction takes. */
+    private recent;
+    private _query;
+    get config(): DataSource<TRow> | undefined;
+    /** Whether the grid fetches its own rows. With no datasource every getter here is inert. */
+    get enabled(): boolean;
+    /** Whether the server answers a group level, which is what puts *Group by* back in the column menu. */
+    get canGroup(): boolean;
+    /**
+     * Whether the levels are a tree's rather than a grouping's. The two are one mechanism — a path, a level
+     * per open path, the same eviction — and they are mutually exclusive because a level cannot be both:
+     * a tree's own rows are the grouping its data already has.
+     */
+    get isTree(): boolean;
+    /**
+     * The columns the server is grouping by, outermost first. A level at depth `d` holds groups of
+     * `groupBy[d]`; a level as deep as this is long holds leaf rows.
+     */
+    get groupBy(): Key[];
+    get blockSize(): number;
+    private get maxBlocks();
+    /**
+     * Bumped by every change that makes the cache stale. The adapter's fetch effect depends on it, so an
+     * invalidation that leaves the visible range where it was still refills — which every filter does.
+     */
+    get queryVersion(): number;
+    /** The count the server gave for the top level, once it has given one. */
+    get totalCount(): number | undefined;
+    /** Whether any block of any level is in flight — what the loading bar is drawn from. */
+    get isLoading(): boolean;
+    /** The most recent failure still unanswered, which is what the error strip reports. */
+    get error(): unknown;
+    private _segments?;
+    private _byLevel?;
+    /**
+     * The rows the grid draws, as runs of one level each: the top level's rows, with every open group's own
+     * level spliced in directly after the group row that opened it. Rebuilt whenever a block lands or a
+     * group is toggled, and it is also where a level is created and where a closed one is disposed of —
+     * a level nothing reaches is a level whose group has been shut or whose group row has been dropped.
+     */
+    private segments;
+    /** The same runs grouped by the level they came from — how a level's own index becomes a display one. */
+    private byLevel;
+    /** Which rows of a level are open — groups or tree rows — ascending, with the level each one holds. */
+    private expansionsOf;
+    /**
+     * The same for a tree, where every level's rows are data rows and any of them may hold more. A row is
+     * open when it says it has children and the tree model has it open — walked over the blocks in hand,
+     * because a row nobody has fetched is a row nobody could have pressed the chevron of.
+     */
+    private treeExpansionsOf;
+    /**
+     * Every tree row that is open *and* reachable, which is what `onExpandedTreeKeysChange` reports. The
+     * levels are exactly that list: one per open path, and the walk disposes of any the rows no longer
+     * reach — so a row under a shut one is not open however it is marked.
+     */
+    openTreeKeys(): Key[];
+    private levelFor;
+    /** The run a display index falls in, in O(log n) over the runs rather than over the rows. */
+    private segmentAt;
+    /**
+     * How many rows the grid lays out: the walk's own length, which is the top level plus everything open
+     * inside it. With no grouping it is exactly the top level's count, which is all stage 1 ever had.
+     */
+    get rowCount(): number;
+    /** One model per row, by level and then by index, built when somebody looks at that row. */
+    private models;
+    /** How long the last row list was, which is the only thing that can make it stale. */
+    private listLength;
+    /**
+     * The grid's rows. Lazy, because this is the list a million-row grid lays out: a model per row cost
+     * 1.4 seconds of blocked main thread on every block that arrived (measured, Chrome 152), and the rows
+     * read their values through the cache anyway, so there was never anything to rebuild.
+     */
+    rowList(): (RowModel<TRow> | GroupRowModel<TRow>)[];
+    /**
+     * The same rows with each open detail panel after the row that opened it. Only a row that has arrived
+     * can be expanded, so the positions are found by walking the blocks in hand rather than the result set.
+     */
+    flatRowList<TItem>(rows: TItem[]): (TItem | DetailRowModel<TRow>)[];
+    /**
+     * Where the rows sit once the open detail panels are counted in, and how tall the lot is. Lazy for the
+     * same reason the row list is — the binary search the viewport runs over it reads a handful of entries.
+     */
+    rowOffsets(flat: (RowModel<TRow> | GroupRowModel<TRow> | DetailRowModel<TRow>)[]): {
+        offsets: number[];
+        totalHeight: number;
+    };
+    /**
+     * Where each open detail panel sits in the flat list, ascending. The i-th one follows its own row and
+     * the i panels already inserted above it, which is what makes the mapping back an O(log n) search.
+     *
+     * Only a row that has arrived can be expanded, so this walks the blocks in hand — a few thousand rows
+     * at the most — rather than the result set, which is the whole million.
+     */
+    private detailPositions;
+    /**
+     * Every row in hand, in the order they are drawn. Read off the blocks rather than the row list, which
+     * is lazy — and it is the blocks that are the honest answer anyway: a select-all cannot reach rows
+     * nobody has fetched, and with a group shut its rows were never fetched at all.
+     */
+    loadedRows(): TRow[];
+    /** Every data row the cache holds, with where it is drawn — the blocks in hand, never the result set. */
+    private eachLoadedLeafRow;
+    /** The model for one row of the display list, kept so React sees the same object between renders. */
+    private rowModelAt;
+    /** The column a level groups by. It stays in `leafs` while it is grouped, only hidden from the body. */
+    private groupColumnAt;
+    /** How many rows the grid lays out right now: the page's worth, or the whole list. */
+    private visibleLength;
+    /** Which absolute rows are on screen's worth of the display list — a page, or everything. */
+    private visibleRange;
+    rowAt(index: number): TRow | undefined;
+    statusAt(index: number): BlockStatus | 'missing';
+    /**
+     * Ask for everything covering `[startIndex, endIndex)` of the display list. Called from an effect with
+     * the viewport's own window; when the grid is paginated the page is the range, so the pager and the
+     * scroller are one path. A range crossing an open group asks its level for a block of its own.
+     */
+    request(startIndex: number, endIndex: number): void;
+    /**
+     * A group opened or closed. The walk over the levels is a different walk now — and this is the only
+     * change that reaches it without a block having moved, so nothing else would drop the cached one.
+     */
+    expansionChanged(): void;
+    /** Fetch every block that failed, which is what the error strip's Retry does. */
+    retry: () => void;
+    /**
+     * The query changed underneath the cache: every block is about a question nobody is asking any more.
+     * Requests in flight are aborted, and the next `request` refills from wherever the viewport now is —
+     * which the adapter has put back at the top, since a new query has no scroll position to preserve.
+     *
+     * The count is deliberately *kept*: the next response replaces it, and dropping it in between collapses
+     * the scrollbar to one block and the pager to one page on every keystroke in a filter box.
+     */
+    invalidate(): void;
+    /** Mark a block as wanted now, so eviction takes the ones the viewport left behind. */
+    private touch;
+    private bump;
+    /** Drop the least recently wanted blocks, and abort any of them still in flight. */
+    private evict;
+    /**
+     * Rows moved, so React has to hear about it. The row list itself is rebuilt only when its *length*
+     * changes: the models read their values through this cache, so a block arriving changes what fifty
+     * rows show without one of them being replaced — which is what keeps a selection and a focused cell
+     * where they were. The flat list is another matter, since a row that has only just arrived may be one
+     * whose detail panel is open, or one whose group somebody left expanded.
+     */
+    changed(): void;
+}
+/** How many of an ascending list of positions fall below `value` — a lower bound, in O(log n). */
+export declare function countBelow(positions: number[], value: number): number;

package/components/dataGrid/models/editModel.d.ts

@@ -0,0 +1,77 @@
+import { CellEdit, CellEditorConfig, Key } from '../contracts/dataGridContract';
+import { default as ColumnModel } from './columnModel';
+import { default as GridModel } from './gridModel';
+import { default as RowModel } from './rowModel';
+/** What a rejection with no message of its own says. A silent refusal is one nobody can act on. */
+export declare const DEFAULT_EDIT_ERROR = "Invalid value";
+/** A key that starts an edit by replacing the value: one printable character, unmodified. */
+export declare function isTypingKey(event: React.KeyboardEvent): boolean;
+/**
+ * Cell editing: which cell is open, what is in it, what a commit is judged by, and the values the grid
+ * has accepted. All of it lives here rather than in the editor component, so the four built-in editors
+ * and one of your own are the same three calls — read `draft`, `setDraft`, `commit` or `cancel`.
+ *
+ * The accepted values are an **overlay** on the rows the grid was given: it does not own `data`, and a
+ * grid over a `def.dataSource` owns even less of it, so a value that was only reported would be gone
+ * again on the next render. It is read where a value is *displayed* — cells and exports — and nowhere a
+ * value is *compared*, so an edit never re-sorts or re-filters the grid under the person making it.
+ */
+export default class EditModel<TRow> {
+    readonly grid: GridModel<TRow>;
+    constructor(grid: GridModel<TRow>);
+    /** The accepted values, keyed by cell. Cleared by `clearEdits()` and by a datasource refresh. */
+    private readonly values;
+    private _edits;
+    private _active?;
+    private _token;
+    /** Whether any column can be edited — what decides the grid reads a keystroke as a way in. */
+    get enabled(): boolean;
+    /** Whether this row and column can be edited. A row nobody has fetched yet cannot. */
+    isEditable(row: RowModel<TRow>, column: ColumnModel<TRow>): boolean;
+    /** The editor a cell opens, worked out from the value in it when the column names none. */
+    editorFor(column: ColumnModel<TRow>, value: unknown): CellEditorConfig<TRow>;
+    isEditing(rowKey: Key, columnKey: Key): boolean;
+    /** What is in the open editor. `undefined` when none is open, which a cell checks with `isEditing`. */
+    get draft(): unknown;
+    /** What the last commit was rejected with. The editor stays open on it. */
+    get error(): string | undefined;
+    /** Whether an async validator has been asked and has not answered. */
+    get pending(): boolean;
+    /**
+     * Open an editor. `initial` is what a printable key typed on the cell starts it with — the value it
+     * replaces rather than one it is appended to, which is how every spreadsheet reads a keystroke. Only
+     * the two editors that are *typed into* take it; see `seedFor`.
+     */
+    begin(row: RowModel<TRow>, column: ColumnModel<TRow>, value: unknown, initial?: string): void;
+    /** Open the editor on a cell named by grid coordinates, which is where Tab lands. */
+    beginAt(row: number, column: number, initial?: string): boolean;
+    setDraft(value: unknown): void;
+    /** Close the editor with nothing written. Also what an accepted commit does on its way out. */
+    cancel(): void;
+    /**
+     * Accept the draft, if `def.onCellEdit` lets it. A value that did not change is not an edit at all and
+     * closes the editor without asking, which is what makes Tab through a row of cells cost nothing.
+     */
+    commit(): void;
+    /** What an answer — a validator's, or its own for a synchronous edit — does to the open editor. */
+    private settle;
+    /** What a cell shows: the accepted value when there is one, the row's own otherwise. */
+    valueOf(rowKey: Key, columnKey: Key, raw: unknown): unknown;
+    /** Every edit the grid has accepted, oldest first. */
+    get edits(): CellEdit<TRow>[];
+    /**
+     * Give the edits back to the host: the values stop being the grid's and the rows answer for themselves
+     * again. A datasource refresh does the same on its own — the blocks are being fetched afresh, so what
+     * the server says next is the newer answer.
+     */
+    clearEdits: () => void;
+    /**
+     * The next editable cell, as a pair of grid coordinates — along the row first and on into the rows
+     * after it, which is the order Tab walks a spreadsheet in. Nothing when there is none: Tab then does
+     * what Tab does in a grid, and leaves.
+     */
+    nextEditable(row: number, column: number, back?: boolean): {
+        row: number;
+        column: number;
+    } | undefined;
+}

package/components/dataGrid/models/exportModel.d.ts

@@ -0,0 +1,51 @@
+import { DataGridExportOptions, ExportTable, Key } from '../contracts/dataGridContract';
+import { default as ColumnModel } from './columnModel';
+import { default as GridModel } from './gridModel';
+/**
+ * What an export writes, decided here and rendered by nobody: the columns, the rows the filters and the
+ * sort left, and the grouping as levels rather than as indentation. Both formats are handed this same
+ * table, which is why a CSV and a workbook of the same grid hold the same figures.
+ *
+ * It is a model rather than part of the writers so that it can be tested without producing a file, and so
+ * the writers stay in the lazy chunk — this is the only export code the grid's own bundle carries.
+ */
+export default class ExportModel<TRow> {
+    readonly grid: GridModel<TRow>;
+    constructor(grid: GridModel<TRow>);
+    /**
+     * The columns a file gets: the visible data columns, **plus** the ones grouping took off the screen.
+     * A grouped column is not hidden — its values moved to the group rows — and a spreadsheet with no
+     * Country column in it is not the grid that was exported.
+     */
+    columns(keys?: Key[]): ColumnModel<TRow>[];
+    /** A column's heading, which is its own `header` or the key it reads. */
+    header(column: ColumnModel<TRow>): string;
+    /** Its width in characters — the unit a spreadsheet sizes columns in, from the pixels the grid uses. */
+    width(column: ColumnModel<TRow>): number;
+    /**
+     * One row's value for one column: the column's own `exportValue` when it has one, else the raw field —
+     * either way through the edits, so a file carries what the grid is showing rather than what it was given.
+     */
+    private value;
+    /** A column's aggregate over a set of rows, or null where it has no aggregation. */
+    private aggregateOf;
+    /**
+     * The table. Group rows carry their own value in the column they group by and a total in every column
+     * that aggregates; a collapsed group exports collapsed, so the file opens looking like the screen.
+     */
+    table(options?: DataGridExportOptions): ExportTable;
+    /**
+     * A tree, as Excel's outline: a row's level is its depth and a shut row exports `collapsed`, with
+     * everything under it `hidden` — the same two flags a collapsed group writes, so the file opens
+     * looking like the screen. The rows are walked rather than the models: a shut row builds none of its
+     * children, and an export writes the whole tree.
+     */
+    private walkTree;
+    /**
+     * The grand totals, over the rows the filters left. The label goes in the leading column with nothing
+     * of its own to say — the same column it occupies on screen when that column is exported at all.
+     */
+    private footerRow;
+    /** The file's name, without an extension: what was asked for, else the grid's title, else `export`. */
+    fileName(options?: DataGridExportOptions): string;
+}