nexus-shared 2.0.0 → 3.0.0

package/dist/Interfaces/CrudInterfaces.d.ts

@@ -1,20 +1,21 @@
 import type { CSSProperties, ReactNode, Ref } from "react";
 import type { PopupSize } from "../Components/Layouts/Popup.tsx";
+import type { FormStore } from "../Helpers/FormStore.ts";
 import type { TableStore } from "../Helpers/TableStore.ts";
 import type { ApiEndpoint } from "./ApiInterfaces.ts";
 import type { FormProps, FormValues, InputParams } from "./FormInterfaces.ts";
 import type { InputDesign } from "./InputInterfaces.ts";
 import type { DataTableProps, TableColumn, TableMassAction, TablePaging, TableRowAction } from "./TableInterfaces.ts";
 /**
- * The lists of a controller: every active record (`normal`), the flagged ones, the archive, the trash, and the deleted
- * ones (which can go back to the trash). The records the user pinned are not a list of their own: they sit above the
+ * The lists of a controller: every active record (`normal`), the flagged ones, the trash, and the deleted ones
+ * (which can go back to the trash). The records the user pinned are not a list of their own: they sit above the
  * active list, and in it.
  */
-export type CrudMode = "normal" | "flag" | "archive" | "trash" | "deleted";
+export type CrudMode = "normal" | "flag" | "trash" | "deleted";
 /** The built-in actions on one record. */
-export type CrudRowActionName = "view" | "edit" | "flag" | "pin" | "archive" | "restore" | "trash" | "recover" | "delete" | "trashFromDelete";
+export type CrudRowActionName = "view" | "edit" | "flag" | "pin" | "trash" | "recover" | "delete" | "trashFromDelete";
 /** The built-in actions on many records at once. */
-export type CrudMassActionName = "flag" | "pin" | "archive" | "restore" | "trash" | "recover" | "delete" | "trashFromDelete" | "description";
+export type CrudMassActionName = "flag" | "pin" | "trash" | "recover" | "delete" | "trashFromDelete" | "description";
 /** Every built-in action: Add, the row actions, and a new description for many records. */
 export type CrudActionName = "create" | CrudRowActionName | "description";
 /**
@@ -38,8 +39,6 @@ export interface CrudEndpoints {
     flag?: ApiEndpoint;
     /** Pins a record, or unpins it: `Room/Pin/{id}`. */
     pin?: ApiEndpoint;
-    archive?: ApiEndpoint;
-    restore?: ApiEndpoint;
     trash?: ApiEndpoint;
     recover?: ApiEndpoint;
     delete?: ApiEndpoint;
@@ -52,10 +51,29 @@ export type CrudInputs<TRow extends FormValues = FormValues> = readonly InputPar
     create?: readonly InputParams[];
     edit?: readonly InputParams[];
 } | ((action: "create" | "edit", row: TRow | null) => readonly InputParams[] | Promise<readonly InputParams[]>);
+/** What a form popup's side panel is handed: the live form, and which record it was opened on. */
+export interface CrudFormAsideContext<TRow extends FormValues = FormValues> {
+    /**
+     * The form of this popup. Read it with `getValue()` and follow it with `subscribeValue()`: the panel then updates
+     * itself without the form around it re-rendering, which is what keeps a long form typeable while the panel works.
+     */
+    form: FormStore<TRow>;
+    action: "create" | "edit";
+    /** The record being edited, or null for a new one. */
+    row: TRow | null;
+}
 /** The Add and Edit popups and their forms. */
 export interface CrudFormOptions<TRow extends FormValues = FormValues> {
     /** Width of the popups. Default `md`, or `lg` for forms of more than 8 inputs. */
     size?: PopupSize;
+    /**
+     * A panel beside the form, in the same popup: a preview of what will be written, a summary, a help panel. It is
+     * given the popup's own `FormStore`, so it can follow what is typed.
+     *
+     * Side by side where there is room; under about 1000px the two stack and the **form comes first**, since that is
+     * what the popup is for. Pair it with a wide `size` (`xl` or `full`): a panel in a 560px popup leaves the form none.
+     */
+    aside?: ReactNode | ((context: CrudFormAsideContext<TRow>) => ReactNode);
     /** Values of a new record, over each input's default. */
     newValues?: Partial<TRow> | (() => Partial<TRow>);
     /**
@@ -80,6 +98,17 @@ export interface CrudFormOptions<TRow extends FormValues = FormValues> {
      */
     draftKey?: string;
 }
+/** What a details popup's side panel is handed: the record, in the shape a form's side panel is handed it. */
+export interface CrudDetailsAsideContext<TRow extends FormValues = FormValues> {
+    /**
+     * The record, in a `FormStore` no input writes to: the row as the list has it at once, then the `details`
+     * endpoint's record when that lands. Read it with `getValue()` and follow it with `subscribeValue()`, exactly as a
+     * form's panel does — so the panel beside the Edit form can be the panel beside the details, unchanged.
+     */
+    form: FormStore<TRow>;
+    /** The row the popup was opened on, as the list has it. */
+    row: TRow;
+}
 /** The details popup that View opens. */
 export interface CrudDetailsOptions<TRow extends FormValues = FormValues> {
     /** The fields to show. Default: every column, hidden ones too. */
@@ -88,6 +117,17 @@ export interface CrudDetailsOptions<TRow extends FormValues = FormValues> {
     render?: (row: TRow) => ReactNode;
     /** Default `md`. */
     size?: PopupSize;
+    /**
+     * A panel beside the details, in the same popup: what the record generates, a chart, a preview. It is laid out as
+     * the Add and Edit popups' `form.aside` is, except that here the panel takes the larger share, since the details
+     * beside it are a short list of fields. Pair it with a wide `size` (`xl` or `full`).
+     */
+    aside?: ReactNode | ((context: CrudDetailsAsideContext<TRow>) => ReactNode);
+    /**
+     * What the popup is called, as a noun: the row's menu offers "View {label}" and the popup's title is
+     * "{Subject} {label}". Default `details`. A popup whose panel is the point says so: `schema`, `preview`.
+     */
+    label?: string;
 }
 /** What changed, for `onChange`. */
 export interface CrudChange<TRow extends FormValues = FormValues> {
@@ -97,7 +137,7 @@ export interface CrudChange<TRow extends FormValues = FormValues> {
     mode: CrudMode;
 }
 /** Table settings a CRUD passes on to its `DataTable`. */
-export type CrudTableOptions<TRow extends FormValues = FormValues> = Pick<DataTableProps<TRow>, "pageSize" | "pageSizes" | "defaultSort" | "numbered" | "maxHeight" | "size" | "searchPlaceholder" | "maxSelection" | "emptyMessage" | "columnsMenu" | "stateKey" | "searchDelay" | "reorderable" | "resizable" | "pinnable" | "moreActions" | "exportable" | "printable" | "exportName" | "onImport">;
+export type CrudTableOptions<TRow extends FormValues = FormValues> = Pick<DataTableProps<TRow>, "pageSize" | "pageSizes" | "defaultSort" | "numbered" | "maxHeight" | "fill" | "excel" | "size" | "searchPlaceholder" | "maxSelection" | "emptyMessage" | "columnsMenu" | "stateKey" | "searchDelay" | "reorderable" | "resizable" | "pinnable" | "moreActions" | "exportable" | "printable" | "exportName" | "onImport" | "openOnClick">;
 /** Props of `Crud`. */
 export interface CrudProps<TRow extends FormValues = FormValues> {
     /** The endpoints: `MODULES.controller(NexusModule.Reservation, "Guest", "guest")`, or an object of your own. */
@@ -133,8 +173,10 @@ export interface CrudProps<TRow extends FormValues = FormValues> {
     /** The details popup, or `false` for none. */
     details?: false | CrudDetailsOptions<TRow>;
     /**
-     * Keeps lists this long (milliseconds) while the page is open, so going back to a list shows it at once; changes update
-     * or drop what is kept. Default 5 minutes; `false` loads every time. Cleared when the page closes.
+     * Keeps lists this long (milliseconds) while the page is open, so going back to a list shows it at once. A change is
+     * **written into** every list kept, from the record the answer carried: a record flagged joins the flagged list and
+     * one trashed joins the trash, with no request on either. Only a list the record cannot answer for is dropped, and
+     * that one loads when it is shown. Default 5 minutes; `false` loads every time. Cleared when the page closes.
      */
     cache?: false | {
         lifetime?: number;
@@ -143,7 +185,7 @@ export interface CrudProps<TRow extends FormValues = FormValues> {
     toolbar?: ReactNode;
     /** Settings of the table. */
     table?: CrudTableOptions<TRow>;
-    /** After every change the CRUD made: a record added, saved, archived, deleted. */
+    /** After every change the CRUD made: a record added, saved, trashed, deleted. */
     onChange?: (change: CrudChange<TRow>) => void;
     /** The table's name for screen readers. Default: the plural of the subject ("Guests"). */
     "aria-label"?: string;
@@ -160,8 +202,27 @@ export interface CrudHandle<TRow extends FormValues = FormValues> {
     /** The list shown. */
     mode: CrudMode;
     setMode: (mode: CrudMode) => void;
-    /** Loads the list again, past the cache. */
+    /** Loads the list again, past the cache. A last resort: `apply` writes a change in without a request. */
     reload: () => Promise<void>;
+    /**
+     * Records a page's **own** action changed, written where the built-in actions write theirs: into the table, the
+     * pinned band and every list kept in the cache - no request, on any list. Each record is merged over the one the
+     * table holds, so the key and the fields that changed are enough:
+     *
+     * ```ts
+     * const answer = await api.send(REGION_MARKS.flag, { params: { id: row.id } });
+     * if (answer.ok) handle.current?.apply([{ ...row, recordStatus: answer.result }]);
+     * ```
+     *
+     * Which list each record now belongs in comes from the record itself (`CrudBackend.listMembership`), so one that
+     * no longer belongs to the list on screen leaves it, and the other lists are patched behind it. `gone` is for an
+     * action that ends a record: it is taken out of every list.
+     *
+     * It does not call `onChange`, since the page calling it is the one that made the change.
+     */
+    apply: (rows: readonly Partial<TRow>[], options?: {
+        gone?: boolean;
+    }) => void;
     /** Opens the Add popup, with these values over the new record's. */
     create: (values?: Partial<TRow>) => void;
     /** Opens the Edit popup of a record. */

package/dist/Interfaces/ExcelInterfaces.d.ts

@@ -0,0 +1,215 @@
+import type { ApiEndpoint, ApiModuleValue, AppModule } from "./ApiInterfaces.ts";
+/**
+ * What one column of a sheet holds. It decides the cell's format in the file, the check the spreadsheet makes while
+ * the person types, and the input the review editors draw. The numbers are the backend's (`EExcelDataTypes`); an
+ * object, not an enum, so a test that strips types can import it.
+ */
+export declare const ExcelDataType: {
+    /** One line of text: a name, a code. */
+    readonly Text: 0;
+    /** Many lines of text: a description, a note. */
+    readonly Note: 1;
+    /** A whole number, no decimals. */
+    readonly WholeNumber: 2;
+    /** A number with decimals. */
+    readonly Decimal: 3;
+    /** Money: decimals fixed at the backend's places. */
+    readonly Amount: 4;
+    /** A date with no time, as an ISO date: `2026-09-29`. */
+    readonly Date: 5;
+    /** A date and a time, zone-less, as `2026-09-29 14:30`. */
+    readonly DateTime: 6;
+    /** A time of day with no date: `14:30`. */
+    readonly Time: 7;
+    /** Yes or No. */
+    readonly YesNo: 8;
+    /** A choice from a list the backend owns, picked in the sheet and travelling as its key. */
+    readonly List: 9;
+};
+export type ExcelDataType = (typeof ExcelDataType)[keyof typeof ExcelDataType];
+/** What one row of an upload turned out to be. The backend's `EExcelRowKinds`. */
+export declare const ExcelRowKind: {
+    /** Nothing is wrong with it and it is not a record yet: this is what an import writes. */
+    readonly New: 0;
+    /** It is already a record, or repeats a row earlier in the file. Nothing updates it. */
+    readonly Duplicate: 1;
+    /** Something in it has to be fixed before it can be written. */
+    readonly Invalid: 2;
+};
+export type ExcelRowKind = (typeof ExcelRowKind)[keyof typeof ExcelRowKind];
+/** One column of a sheet: enough to draw a heading, know what the cell holds, and check it before anything is sent. */
+export interface ExcelColumnInfo {
+    /** The property behind it, and the key every row's values are held under: `CityName`. */
+    field: string;
+    /** The heading the person reads: "City name". */
+    header: string;
+    dataType: ExcelDataType;
+    /** A row with this cell empty is refused. */
+    isRequired?: boolean;
+    /** The file fills it, not the person. */
+    isReadOnly?: boolean;
+    /** It is a choice: it travels as a key with its words beside it, and is picked in the sheet. */
+    isReference?: boolean;
+    /** The list it picks from. */
+    list?: string | null;
+    minLength?: number;
+    maxLength?: number;
+    /** Least value of a number. Only a number has one. */
+    minimum?: number | null;
+    /** Most value of a number. */
+    maximum?: number | null;
+    /** What the person reads about this column, in their words. */
+    note?: string | null;
+}
+/**
+ * The limits and the shape of a sheet, asked for before either side is offered: so an export that will be cut short is
+ * said before it is written, and the editors know what they are drawing. It is the same for everybody and changes once
+ * a release, so it is kept.
+ */
+export interface ExcelSettings {
+    /** What one row is: "City". */
+    subject: string;
+    /** What the downloaded template is called. */
+    templateFileName?: string;
+    /** Rows the template offers to fill. */
+    sheetRows?: number;
+    /** The most rows one export writes. Over this, the person is warned first. */
+    maxExportRows: number;
+    /** The most rows one import takes. */
+    maxImportRows: number;
+    /** The columns, in the order they read. */
+    columns: ExcelColumnInfo[];
+    /**
+     * How each column should be drawn as an input. **Empty** until the backend can describe an input, and `columns` is
+     * what the editors draw from until it is not.
+     */
+    inputs?: readonly unknown[];
+}
+/** One thing wrong with one cell, told so the person can find it. */
+export interface ExcelCellProblem {
+    /** The row of the sheet, the number down the side of the file. */
+    row: number;
+    /** The column, counting from 1. */
+    column: number;
+    /** The cell as a spreadsheet names it: `B7`. */
+    cell: string;
+    /** The column's heading, in the person's words. */
+    header: string;
+    /** The property behind it, which is what an editor binds to. */
+    field: string;
+    /** What to tell the person, in plain words. */
+    message: string;
+    /** The unique code of the line that found it, for a developer. */
+    messageCode?: string;
+    /** What kind of failure it is, as a number. */
+    errorCode?: number;
+}
+/** One row of the review: what it holds, what it turned out to be, and what is wrong with it. */
+export interface ExcelReviewRow {
+    /** The row of the sheet, so the person can find it in their own file. */
+    number: number;
+    kind: ExcelRowKind;
+    /** What each column held, by the property's name. A choice holds its key, never a plain id. */
+    values: Record<string, string | null>;
+    /** What the person picked in each choice, for the review to show. */
+    labels?: Record<string, string | null>;
+    /** Everything wrong with the row, one per cell. */
+    problems?: ExcelCellProblem[];
+    /** Why it is a duplicate, in the person's words. */
+    duplicate?: string | null;
+}
+/** What a verify answers: the whole upload, counted and told row by row. Nothing was written. */
+export interface ExcelVerifyAnswer {
+    /** What one row is. */
+    subject: string;
+    /** Rows that had something in them. Empty rows of the template are not counted. */
+    read: number;
+    /** Rows an import would write. */
+    new: number;
+    /** Rows that are already records, or repeat one earlier in the file. */
+    duplicates: number;
+    /** Rows with something to fix. */
+    invalid: number;
+    /** An import would write something and nothing is waiting on a fix. */
+    isReady: boolean;
+    /** The upload in one sentence, for above the review. */
+    note: string;
+    /** The columns, in the order they read. */
+    columns: ExcelColumnInfo[];
+    /** Every row that had something in it. */
+    rows: ExcelReviewRow[];
+    /** Empty until the backend can describe an input. */
+    inputs?: readonly unknown[];
+}
+/**
+ * One row as it travels, in text and nothing else. The same shape in both directions, which is the point: a verify
+ * reads it out of the file and answers with it, the person fixes what they need to, and the import sends the same rows
+ * back to be read again by the same code. A reference column holds its key.
+ */
+export interface ExcelSheetRow {
+    /** The row of the sheet this came from, so every problem can name where it is. */
+    number: number;
+    /** What each column held, by the property's name. A reference holds its key. */
+    values: Record<string, string | null>;
+    /** What the person picked in each reference column: "Nepal (NP)". */
+    labels?: Record<string, string | null>;
+}
+/** What an import did: what it wrote, and what it did not, in the person's words. */
+export interface ExcelImportAnswer {
+    /** Rows the request carried. */
+    sent: number;
+    /** Records written. */
+    created: number;
+    /** Rows that were already records. Nothing was updated. */
+    duplicates: number;
+    /** Rows that still had something to fix. */
+    invalid: number;
+    /** The rows nothing was written for, so the person sees which and why without asking again. */
+    refused?: ExcelReviewRow[];
+    /** What happened, in one sentence. */
+    note: string;
+}
+/**
+ * The endpoints of one model's spreadsheets. `excelEndpoints` builds the Nexus ones; an app on another backend writes
+ * its own object of the same four or five.
+ *
+ * `export` is the model's own action, because only the model knows what the person has on screen - the search, the
+ * filters, which list they are looking at, and whose rows they may see. Without one, no export is offered.
+ */
+export interface ExcelEndpoints<TModule extends ApiModuleValue = AppModule> {
+    /** The limits and the shape of the sheet. The one answer a browser may keep. */
+    settings: ApiEndpoint<TModule>;
+    /** The template to fill, as a file. */
+    template: ApiEndpoint<TModule>;
+    /** A filled file read and judged, with nothing written. */
+    verify: ApiEndpoint<TModule>;
+    /** Writes the rows a verify answered with, as the person left them. */
+    import: ApiEndpoint<TModule>;
+    /** The model's own export, with the search on screen. */
+    export?: ApiEndpoint<TModule>;
+}
+/** What the person has on screen, as an export asks for it. The model's own filters go in `filters`. */
+export interface ExcelExportQuery {
+    /** The search box's text. */
+    search?: string | null;
+    /** The sorted column, as the server names it. */
+    sort?: string | null;
+    /** Which way it is sorted. */
+    direction?: "asc" | "desc";
+    /** The filters the page holds, sent as they are: a list, a date range, a status. */
+    filters?: Record<string, unknown>;
+}
+/** A file an endpoint answered with, and what it says about itself. */
+export interface ExcelDownload {
+    blob: Blob;
+    /** The name the answer gave it (`Content-Disposition`), else the one that was asked for. */
+    fileName: string;
+    /** Rows written into the file, when the answer says. */
+    rows?: number;
+    /** Rows asked for that did not fit under the limit. */
+    skipped?: number;
+    /** The most rows one export writes, as the backend has it. */
+    limit?: number;
+    /** What to tell the person when rows were left out. */
+    note?: string;
+}

package/dist/Interfaces/ExcelInterfaces.js

@@ -0,0 +1,45 @@
+/*
+ * Types of the spreadsheet side: what a model's sheet is made of, what a verify answers, what an import sends back, and
+ * the endpoints that serve all three. One shape travels both ways (`ExcelSheetRow`), so a verify and an import can
+ * never disagree about a row.
+ *
+ * A reference column travels as its **key** - an encrypted id made for the person who downloaded the file - with the
+ * words they picked beside it. The plain id in the sheet is theirs to read and is never read back, so a value copied
+ * out of a spreadsheet, or out of a verify answer, cannot be posted to an endpoint as an id.
+ */
+/**
+ * What one column of a sheet holds. It decides the cell's format in the file, the check the spreadsheet makes while
+ * the person types, and the input the review editors draw. The numbers are the backend's (`EExcelDataTypes`); an
+ * object, not an enum, so a test that strips types can import it.
+ */
+export const ExcelDataType = {
+    /** One line of text: a name, a code. */
+    Text: 0,
+    /** Many lines of text: a description, a note. */
+    Note: 1,
+    /** A whole number, no decimals. */
+    WholeNumber: 2,
+    /** A number with decimals. */
+    Decimal: 3,
+    /** Money: decimals fixed at the backend's places. */
+    Amount: 4,
+    /** A date with no time, as an ISO date: `2026-09-29`. */
+    Date: 5,
+    /** A date and a time, zone-less, as `2026-09-29 14:30`. */
+    DateTime: 6,
+    /** A time of day with no date: `14:30`. */
+    Time: 7,
+    /** Yes or No. */
+    YesNo: 8,
+    /** A choice from a list the backend owns, picked in the sheet and travelling as its key. */
+    List: 9,
+};
+/** What one row of an upload turned out to be. The backend's `EExcelRowKinds`. */
+export const ExcelRowKind = {
+    /** Nothing is wrong with it and it is not a record yet: this is what an import writes. */
+    New: 0,
+    /** It is already a record, or repeats a row earlier in the file. Nothing updates it. */
+    Duplicate: 1,
+    /** Something in it has to be fixed before it can be written. */
+    Invalid: 2,
+};

package/dist/Interfaces/FormInterfaces.d.ts

@@ -21,6 +21,8 @@ import type { InputDesign, OptionValue } from "./InputInterfaces.ts";
 import type { Size } from "./TypeInterfaces.ts";
 /** Where a form places an input. The input itself ignores these keys. */
 export interface InputLayoutParams {
+    /** Optional heading before this field when the section changes (Form only). */
+    section?: string;
     /** Columns the input spans in a form's 12-column grid, and in a group form's section. Default 12, the full width. */
     span?: number;
     /** The column's width in a tabular form: a CSS length ("9rem") or pixels. Default by type, e.g. 10rem for text. */
@@ -29,6 +31,17 @@ export interface InputLayoutParams {
     grow?: number;
     /** Leaves the input out, e.g. a field only some roles may see. Its value stays in the data as it was. */
     hidden?: boolean;
+    /**
+     * Other inputs of the same form this one follows (Form only). When any of their values changes, this input draws
+     * again — without mounting again, so nothing typed in it is lost — and its params are read afresh: a getter for
+     * `hidden`, `readOnly`, `readOnlyMessage`, `label`, `hint` or `options` answers for the values as they are now. Its
+     * own rule is checked again too, so a `required` that a getter just switched on or off counts at once. Name the
+     * input itself to follow its own typing (a hint that says what the typed text will become).
+     *
+     * An input that names any is asked `hidden` every time it draws, so it can come and go; one that names none is
+     * asked once, when the form draws.
+     */
+    dependsOn?: readonly string[];
 }
 /** What every input's params have. */
 export interface InputParamsBase<TType extends string = string> extends InputLayoutParams {
@@ -140,6 +153,42 @@ export interface RowsInputProps<TRow extends RowValue = RowValue> {
     removable?: boolean;
     /** Rows can be moved up and down. Default false. */
     sortable?: boolean;
+    /**
+     * Values a row's **position** decides rather than the user: a bitwise enum's value, a line number, a running total.
+     * It is asked after every change — a value typed, a row added, removed, duplicated or **moved** — with every row,
+     * and returns one patch per row (or nothing at all, or nothing for a row).
+     *
+     * The patches are written as if code had set them, so only the cells whose value really changed are drawn again:
+     * moving a row renumbers the column in front of the user and leaves focus where they put it. It runs after every
+     * change, so keep it quick, and pair it with `cellReadOnly` when the user must not type what it writes.
+     */
+    deriveRows?: (rows: TRow[]) => (Partial<TRow> | null | undefined)[] | null | undefined;
+    /**
+     * Which cells hold a **generated** value rather than a typed one: an enum's bitwise value, a line's total. It is
+     * asked for every cell as it renders, so a column can lock and unlock while the form around it changes — params are
+     * fixed once a form opens, and this is the one thing about a cell that is not.
+     *
+     * Return the reason to lock the cell and say why (the input wears its read-only lock and shows the note), `true` to
+     * lock it without a reason, or nothing to leave the cell as its params have it. Locking a cell never stops code from
+     * writing it: that is the point.
+     */
+    cellReadOnly?: (row: TRow, name: string, index: number) => string | boolean | null | undefined;
+    /**
+     * Rows the user did not write and may not change, such as the fields a class inherits from its parent: every cell of
+     * such a row is read-only with the reason returned, and in a tabular form its menu offers nothing and no row can be
+     * moved above it. Return the reason, `true` for no reason, or nothing. Keep such rows first: nothing reorders them.
+     */
+    rowReadOnly?: (row: TRow, index: number) => string | boolean | null | undefined;
+    /**
+     * Params of one cell that differ from its column's: a picker whose choices depend on the row, such as a type argument
+     * that takes a key type in one row and a model in the next. Asked as the row draws, which is when one of its values
+     * changes; return the keys to change (`{ options, selectedOptions }`), or nothing for the column's own params.
+     *
+     * Return the **same object** for the same answer (keep them in a map by what decides them): a new object draws the
+     * cell again, and a picker indexes its options once per array. Rules still come from the column's params — a row's
+     * value is checked the same way in every row — so change what is offered here, not what is required.
+     */
+    cellParams?: (row: TRow, name: string, index: number) => Partial<InputParams> | null | undefined;
     /** Every input is read-only, and rows cannot be added, removed, or moved. */
     readOnly?: boolean;
     /** What the rows say when someone tries to change them. Default "Read-only: these rows cannot be changed." */
@@ -333,8 +382,9 @@ export interface ApiFormProps<TValues extends FormValues = FormValues> extends O
     /** Shapes what is sent, e.g. `{ items: [values] }` for a batch endpoint. May be async. Default: the values. */
     transform?: (values: TValues, context: FormSubmitContext<TValues>) => unknown;
     /**
-     * Reads the server's answer. Default `readApiResponse`: Nexus API responses (`{ isSuccess, message, inputName, result }`),
-     * ASP.NET Core problem details (`{ title, errors }`), and any JSON by its HTTP status.
+     * Reads the server's answer. Default: the app's reader (`configureApi({ read })`), else `readApiResponse`: Nexus API
+     * responses (`{ isSuccess, message, inputName, result }`), ASP.NET Core problem details (`{ title, errors }`), and
+     * any JSON by its HTTP status.
      */
     readResponse?: (body: unknown, status: number | undefined) => ApiResult;
     /** After a save, once the saved values are the form's own, with what the server sent back: close a popup, update a table row. */

package/dist/Interfaces/MessageInterfaces.d.ts

@@ -1,5 +1,5 @@
 /** The actions the builder knows by name (`MESSAGE_ACTION_NAMES`); `actionWords(name)` gives their words. */
-export type MessageActionName = "load" | "save" | "create" | "update" | "delete" | "trash" | "archive" | "restore" | "recover" | "flag" | "unflag" | "pin" | "unpin" | "send" | "submit" | "upload" | "download" | "import" | "export" | "copy" | "approve" | "reject" | "cancel";
+export type MessageActionName = "load" | "save" | "create" | "update" | "delete" | "trash" | "restore" | "recover" | "flag" | "unflag" | "pin" | "unpin" | "send" | "submit" | "upload" | "download" | "import" | "export" | "copy" | "approve" | "reject" | "cancel";
 /** The words of an action. */
 export interface ActionWords {
     /** "save", or with the object inside: "move {object} to the trash". */

package/dist/Interfaces/TableInterfaces.d.ts

@@ -1,5 +1,6 @@
 import type { CSSProperties, ReactNode, Ref } from "react";
 import type { TableStore } from "../Helpers/TableStore.ts";
+import type { ExcelEndpoints } from "./ExcelInterfaces.ts";
 import type { Size, Tone } from "./TypeInterfaces.ts";
 /** A row's id: its `rowKey` field, such as `id`. */
 export type TableKey = string | number;
@@ -20,6 +21,15 @@ export interface TableColumn<TRow extends TableRow = TableRow> {
     key: string;
     /** The heading, and the column's name in the Columns menu and the details view. */
     label: string;
+    /**
+     * The heading of the band above this column: "Amount details" over the quantity, the price, and the total. Columns
+     * next to each other that name the same group share one heading spanning them all, and the columns with no group keep
+     * one heading of their own, as tall as both rows. A table whose columns name no group has one header row, as before.
+     *
+     * The bands are read off the order on screen, so a column the user drags out of its run takes its group's heading
+     * with it and the run it left is drawn with the same heading twice.
+     */
+    group?: string;
     /** Default `text`. Numbers, money, and percents line up at the end; dates and times follow the user's settings. */
     format?: TableColumnFormat;
     /** Digits after the decimal point of a number (money: 2). */
@@ -144,6 +154,32 @@ export interface TableViewColumn<TRow extends TableRow = TableRow> {
     /** Its width in pixels, once the user has set one. */
     width?: number;
 }
+/**
+ * One cell of the band above the headings: a group's heading over the columns next to each other that name it, or a
+ * single column with no group, whose own heading stands in the band row and is as tall as both rows.
+ */
+export interface TableHeadBand<TRow extends TableRow = TableRow> {
+    /** The heading above the columns, or `null` for a column with no group. */
+    group: string | null;
+    /** The columns under it, in the order they are drawn. One, for a column with no group. */
+    columns: TableViewColumn<TRow>[];
+}
+/**
+ * What a table needs to work a spreadsheet: the model's Excel endpoints, and what the page knows that the table does
+ * not. The search, the sort, and how many rows the search leaves are the table's own and are sent for it.
+ */
+export interface TableExcel {
+    /** The model's endpoints, from `excelEndpoints(controller)`. */
+    endpoints: ExcelEndpoints;
+    /** What one row is, for the questions and the messages: "city". Default: what the backend's settings say. */
+    subject?: string;
+    /** Values the endpoints' own params need, such as a parent's id. */
+    params?: Record<string, string | number>;
+    /** The filters the page holds, beside the table's search and sort, read when an export is asked for. */
+    filters?: () => Record<string, unknown>;
+    /** After an import wrote something. The table reloads itself either way. */
+    onImported?: () => void;
+}
 /** An item of the table's options menu (⋮): Import, Print, a report of the page's own. */
 export interface TableMenuAction {
     /** Tells items apart; a test or a style can find it by `data-action`. */
@@ -196,7 +232,7 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
     load?: TableLoader<TRow>;
     /** Default `client`. */
     paging?: TablePaging;
-    /** Loads again, from the first page, when it changes: another list behind the same table, such as a CRUD's archive. */
+    /** Loads again, from the first page, when it changes: another list behind the same table, such as a CRUD's trash. */
     loadKey?: string | number;
     /** The field that tells rows apart. Default `id`. */
     rowKey?: string | ((row: TRow) => TableKey);
@@ -215,8 +251,17 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
     toolbar?: ReactNode;
     /** At the end of the bar: an Add button. */
     actions?: ReactNode;
-    /** The Columns menu, to show and hide columns. Default true. */
+    /** The Columns panel, where columns are shown, hidden, and dragged into another order. Default true. */
     columnsMenu?: boolean;
+    /**
+     * The spreadsheet side of this table, against the backend's Excel controller. The options menu (⋮) then offers
+     * **Download template**, **Import from a spreadsheet** (the file is verified, the person goes over the rows, and the
+     * table reloads once they are written) and, where the endpoints have one, **Export to Excel** - which asks the
+     * server with the search and the sort on screen instead of writing a file of the rows this browser happens to hold.
+     *
+     * It replaces `onImport`, which is the hook for a page that imports its own way.
+     */
+    excel?: TableExcel;
     /** A Reload button. Default true when rows are loaded. */
     reloadable?: boolean;
     /** When the user presses Reload, before the rows load again: drop a cache of your own. */
@@ -249,6 +294,12 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
     rowActions?: (row: TRow) => readonly TableRowAction<TRow>[];
     /** A double-click on a row, such as to open its details. */
     onRowOpen?: (row: TRow) => void;
+    /**
+     * A single click opens a row, not only a double-click: for tables whose rows are opened to be read more than they
+     * are selected. A click on a control in the row (its menu, a link, a checkbox) still does only what that control
+     * does, and so does a click that ends a text selection, so a value can still be copied out of a cell.
+     */
+    openOnClick?: boolean;
     /**
      * Rows kept in a section above the page, which the user folds open: the records they pinned. They are the rows as
      * they came from their own endpoint, and the same records also show in the list below. Leave it out for no section.
@@ -282,6 +333,15 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
     emptyAction?: ReactNode;
     /** The tallest the table grows before its rows scroll under a header that stays: pixels or a CSS length. */
     maxHeight?: number | string;
+    /**
+     * The table takes the whole height it is given instead of growing with its rows: the bar stays on top, the rows
+     * scroll inside the frame under a header that stays, and the footer sits at the bottom of the page. The page around
+     * it never scrolls, so the footer never moves and no scrollbar comes and goes as rows load.
+     *
+     * It needs a parent with a height. An `AdminPage` gives it one: the admin shell is exactly the window, and a page
+     * holding a filling table stretches it to the room under the heading. `maxHeight` is ignored while it is on.
+     */
+    fill?: boolean;
     /** Row height and text size. Default `md`. */
     size?: Extract<Size, "sm" | "md">;
     id?: string;