nexus-shared 3.0.0 → 3.1.0

package/dist/Components/Viewers/DataTableFilters.js

@@ -0,0 +1,68 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { iconFilterOff, InlineIcon } from "nexus-icons";
+import { useEffect, useId, useRef } from "react";
+import { usePopoverPanel } from "../../Helpers/PopoverHooks.js";
+import { activeFilters } from "../../Helpers/TableFilters.js";
+import { Button } from "../Documents/Button.js";
+import { Form, useForm } from "../Forms/Form.js";
+import { formatCount } from "./DataTableParts.js";
+/*
+ * The Filters panel: the table's filter inputs as one small form under the options button (⋮), applied as they change.
+ * A choice applies at once; a value that can come a key or a step at a time (text, a number, a slider, a date) waits
+ * the table's search delay, or Enter, or the panel closing. Esc closes the panel, an open list or calendar first, and
+ * never clears a filter on its way out.
+ */
+/** Inputs typed into or dragged: their value waits until the person stops. A date box reads a date from part of one. */
+const TYPED = new Set(["text", "email", "search", "tel", "url", "textarea", "number", "slider", "range-slider", "date", "date-range", "time", "date-time"]);
+/** The Filters panel, opened through its `open()` handle: a `Form` of the filter inputs, the count, and Clear all. */
+export function TableFiltersPanel({ inputs, value, delay, matches, total, onChange, anchor, ref }) {
+    const titleId = useId();
+    const form = useForm();
+    // The form is drawn on the first open and kept: what was typed, and the labels a server list loaded, stay.
+    const { panelRef, shown, onToggle } = usePopoverPanel(anchor, ref, () => form.focus());
+    const pending = useRef(undefined);
+    const count = value ? Object.keys(value).length : 0;
+    const apply = () => {
+        clearTimeout(pending.current);
+        pending.current = undefined;
+        onChange(form.getValue());
+    };
+    const wait = () => {
+        clearTimeout(pending.current);
+        pending.current = setTimeout(apply, delay);
+    };
+    const flush = () => pending.current !== undefined && apply();
+    // Filters changed from outside reach the form, unless a typed value is still on its way.
+    useEffect(() => {
+        if (form.started && pending.current === undefined && JSON.stringify(activeFilters(inputs, form.getValue())) !== JSON.stringify(value))
+            form.load(value ?? {});
+    }, [form, inputs, value]);
+    useEffect(() => () => clearTimeout(pending.current), []);
+    return (_jsxs("div", { ref: panelRef, popover: "auto", role: "dialog", tabIndex: -1, "aria-labelledby": titleId, className: "nx-popover nx-table-panel nx-table-filters", onToggle: onToggle, onBeforeToggle: event => {
+            // Before the click that closes it lands: a clear that click makes then comes after what was typed.
+            if (event.target === event.currentTarget && event.newState === "closed")
+                flush();
+        }, onKeyDownCapture: event => {
+            // Kept from the inputs, whose Esc clears a value first: with no list or calendar open, Esc closes the panel.
+            if (event.key === "Escape" && !event.currentTarget.querySelector(":popover-open"))
+                event.stopPropagation();
+        }, onKeyDown: event => {
+            if (event.key === "Enter")
+                flush();
+        }, onInput: () => {
+            // A key that changes nothing the box reads ("2025-01-01 -") is typing too: a waiting value waits on.
+            if (pending.current !== undefined)
+                wait();
+        }, children: [_jsxs("div", { className: "nx-table-panel__head", children: [_jsx("span", { className: "nx-table-panel__title", id: titleId, children: "Filters" }), _jsx("span", { className: "nx-table-panel__count", children: count ? `${count} on` : "None" })] }), _jsx("div", { className: "nx-popover__scroll", children: shown && (_jsx(Form, { form: form, inputs: inputs, size: "sm", defaultValue: value, className: "nx-table-filters__form", onValueChange: (_, name) => {
+                        if (name === null)
+                            return;
+                        if (delay > 0 && TYPED.has(inputs.find(params => params.name === name)?.type ?? ""))
+                            wait();
+                        else
+                            apply();
+                    } })) }), _jsxs("div", { className: "nx-table-panel__foot", children: [_jsxs("span", { className: "nx-table-filters__rows", "aria-live": "polite", children: [formatCount(matches), " of ", formatCount(total), " rows"] }), _jsx(Button, { size: "sm", variant: "ghost", icon: _jsx(InlineIcon, { icon: iconFilterOff }), disabled: !count, onClick: () => {
+                            form.load({});
+                            apply();
+                        }, children: "Clear all" })] })] }));
+}

package/dist/Components/Viewers/DataTableParts.d.ts

@@ -127,8 +127,8 @@ export declare function TablePageSize({ pageSize, pageSizes, compact, onChange }
     onChange: (size: number) => void;
 }): import("react").JSX.Element | null;
 /**
- * Under the table: which rows show and how many the search left ("Showing 41–50 of 234 · filtered from 1,000"), the page
- * of how many, and the pager.
+ * Under the table: which rows show and how many the search and the filters left ("Showing 41–50 of 234 · filtered
+ * from 1,000"), the page of how many, and the pager.
  */
 export declare function TableFooter<TRow extends TableRow>({ state, disabled, onPage }: {
     state: TableState<TRow>;

package/dist/Components/Viewers/DataTableParts.js

@@ -143,8 +143,8 @@ export function TablePageSize({ pageSize, pageSizes, compact = false, onChange }
     return (_jsx(Menu, { items: items, kind: "radio", size: "sm", align: compact ? "start" : "end", "aria-label": "Rows per page", onSelect: value => onChange(Number(value)), children: _jsx(Button, { variant: "ghost", size: "sm", iconEnd: _jsx(InlineIcon, { icon: iconChevronDown }), className: cx("nx-table__page-size", compact && "nx-table__page-size--field"), "aria-label": `Rows per page: ${pageSize}`, title: "Rows per page", children: compact ? formatCount(pageSize) : `${formatCount(pageSize)} / page` }) }));
 }
 /**
- * Under the table: which rows show and how many the search left ("Showing 41–50 of 234 · filtered from 1,000"), the page
- * of how many, and the pager.
+ * Under the table: which rows show and how many the search and the filters left ("Showing 41–50 of 234 · filtered
+ * from 1,000"), the page of how many, and the pager.
  */
 export function TableFooter({ state, disabled, onPage }) {
     const { status, rows, offset, matches, total, query } = state;
@@ -153,5 +153,5 @@ export function TableFooter({ state, disabled, onPage }) {
     const first = rows.length ? offset + 1 : 0;
     const last = offset + rows.length;
     const pages = pageCount(matches, query.pageSize);
-    return (_jsxs("div", { className: "nx-table__footer", children: [_jsxs("p", { className: "nx-table__range", "aria-live": "polite", children: [rows.length ? (_jsxs(_Fragment, { children: ["Showing ", _jsx("b", { children: `${formatCount(first)}–${formatCount(last)}` }), " of ", _jsx("b", { children: formatCount(matches) })] })) : (_jsx(_Fragment, { children: "No rows on this page" })), query.search && matches !== total && _jsxs("span", { className: "nx-table__range-all", children: [" \u00B7 filtered from ", formatCount(total)] })] }), _jsxs("div", { className: "nx-table__paging", children: [_jsxs("span", { className: "nx-table__page-info", children: ["Page ", formatCount(query.page), " of ", formatCount(pages)] }), _jsx(TablePager, { page: query.page, matches: matches, pageSize: query.pageSize, disabled: disabled, onPage: onPage })] })] }));
+    return (_jsxs("div", { className: "nx-table__footer", children: [_jsxs("p", { className: "nx-table__range", "aria-live": "polite", children: [rows.length ? (_jsxs(_Fragment, { children: ["Showing ", _jsx("b", { children: `${formatCount(first)}–${formatCount(last)}` }), " of ", _jsx("b", { children: formatCount(matches) })] })) : (_jsx(_Fragment, { children: "No rows on this page" })), (query.search || query.filters) && matches !== total && _jsxs("span", { className: "nx-table__range-all", children: [" \u00B7 filtered from ", formatCount(total)] })] }), _jsxs("div", { className: "nx-table__paging", children: [_jsxs("span", { className: "nx-table__page-info", children: ["Page ", formatCount(query.page), " of ", formatCount(pages)] }), _jsx(TablePager, { page: query.page, matches: matches, pageSize: query.pageSize, disabled: disabled, onPage: onPage })] })] }));
 }

package/dist/Helpers/AnimationHelpers.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Whether things may move, as the stylesheets read it: `data-nx-motion` on `<html>`, which `ThemeScript` works out
+ * from the visitor's Animations choice and the system setting. Motion started from script (a flight, a smooth scroll)
+ * asks this, never `prefers-reduced-motion`, so "on" animates on a machine that reports reduced motion.
+ */
+export declare function motionAllowed(): boolean;
+/**
+ * Whether a scroll may be smooth: the visitor allows motion, and so does the system, because a browser whose system
+ * turned animations off scrolls at once whatever it is asked, and a smooth scroll that is skipped must not be waited on.
+ */
+export declare function smoothScrollAllowed(): boolean;
 /**
  * Calls `done` once the element's CSS animation `name` has finished, or at once when the element runs no animation of
  * that name. Call it after the class that starts the animation is on the element, e.g. in a layout effect.

package/dist/Helpers/AnimationHelpers.js

@@ -1,8 +1,26 @@
 /*
  * Exit animations. A closing element gets a class that starts a CSS animation, and the next step (closing a dialog,
- * removing a toast) waits for it. When no animation runs, the step must not wait: with reduced motion (which Windows
- * reports when its animations are turned off) or when a theme sets `animation: none`.
+ * removing a toast) waits for it. When no animation runs, the step must not wait: with animations off (the visitor's
+ * choice, or the system's under "system" - Windows reports reduced motion when its animations are turned off) or when
+ * a theme sets `animation: none`.
  */
+import { MOTION_ATTRIBUTE } from "../Interfaces/ThemeInterfaces.js";
+import { REDUCED_MOTION_QUERY } from "./ThemeHelpers.js";
+/**
+ * Whether things may move, as the stylesheets read it: `data-nx-motion` on `<html>`, which `ThemeScript` works out
+ * from the visitor's Animations choice and the system setting. Motion started from script (a flight, a smooth scroll)
+ * asks this, never `prefers-reduced-motion`, so "on" animates on a machine that reports reduced motion.
+ */
+export function motionAllowed() {
+    return typeof document === "undefined" || document.documentElement.getAttribute(MOTION_ATTRIBUTE) !== "reduce";
+}
+/**
+ * Whether a scroll may be smooth: the visitor allows motion, and so does the system, because a browser whose system
+ * turned animations off scrolls at once whatever it is asked, and a smooth scroll that is skipped must not be waited on.
+ */
+export function smoothScrollAllowed() {
+    return motionAllowed() && !(typeof window !== "undefined" && window.matchMedia?.(REDUCED_MOTION_QUERY).matches);
+}
 /**
  * Calls `done` once the element's CSS animation `name` has finished, or at once when the element runs no animation of
  * that name. Call it after the class that starts the animation is on the element, e.g. in a layout effect.

package/dist/Helpers/CrudBackend.d.ts

@@ -2,8 +2,11 @@ import type { CrudMassActionName, CrudMode } from "../Interfaces/CrudInterfaces.
 import type { TableKey, TablePage, TableQuery, TableRow } from "../Interfaces/TableInterfaces.ts";
 type Row = Record<string, unknown>;
 export declare abstract class CrudBackend {
-    /** What a server table sends for one page, from the query. `sortKey` is the sorted column's server name. */
-    abstract pageRequest(query: TableQuery, sortKey: string | undefined): unknown;
+    /**
+     * What a server table sends for one page, from the query. `sortKey` is the sorted column's server name. `filters` are
+     * the active filters already in the server's names (`filterRequest`); `query.filters` keeps the raw values.
+     */
+    abstract pageRequest(query: TableQuery, sortKey: string | undefined, filters?: Readonly<Record<string, unknown>>): unknown;
     /** Reads the page a pagination endpoint answered. */
     abstract readPage<TRow extends TableRow>(result: unknown): TablePage<TRow>;
     /** Reads a whole list: an array, or the rows of a page. */
@@ -60,12 +63,12 @@ export declare const NEXUS_TRASH_STATUS = 40;
 /** The Nexus record status of a deleted record (`ERecordStatus.PermanentDeleted`), the bottom of the 60+ delete band. */
 export declare const NEXUS_DELETED_STATUS = 60;
 /**
- * The Nexus backend: pages as `{ searchKeyword, skipCount, maxCount, sorting, sortType }` answered with
+ * The Nexus backend: pages as `{ ...filters, searchKeyword, skipCount, maxCount, sorting, sortType }` answered with
  * `{ results, totalCount, filterCount }`, newest first unless a column is sorted; mass actions send the ids
  * (`{ description, accountIds }` for descriptions); a flagged record has `recordStatus` 25, a pinned one `isPinned`.
  */
 export declare class NexusCrudBackend extends CrudBackend {
-    pageRequest(query: TableQuery, sortKey: string | undefined): unknown;
+    pageRequest(query: TableQuery, sortKey: string | undefined, filters?: Readonly<Record<string, unknown>>): unknown;
     readPage<TRow extends TableRow>(result: unknown): TablePage<TRow>;
     massRequest(action: CrudMassActionName, keys: TableKey[], values?: Row): unknown;
     isFlagged(row: TableRow): boolean;

package/dist/Helpers/CrudBackend.js

@@ -86,13 +86,15 @@ export const NEXUS_DELETED_STATUS = 60;
 /** Just past the flag band: a flagged record is 25–29, so 30 and up is live but not flagged. */
 const NEXUS_FLAG_BAND_END = 30;
 /**
- * The Nexus backend: pages as `{ searchKeyword, skipCount, maxCount, sorting, sortType }` answered with
+ * The Nexus backend: pages as `{ ...filters, searchKeyword, skipCount, maxCount, sorting, sortType }` answered with
  * `{ results, totalCount, filterCount }`, newest first unless a column is sorted; mass actions send the ids
  * (`{ description, accountIds }` for descriptions); a flagged record has `recordStatus` 25, a pinned one `isPinned`.
  */
 export class NexusCrudBackend extends CrudBackend {
-    pageRequest(query, sortKey) {
+    pageRequest(query, sortKey, filters) {
         return {
+            // Flat and first, so a filter never overwrites a paging field.
+            ...filters,
             searchKeyword: query.search,
             skipCount: (query.page - 1) * query.pageSize,
             maxCount: query.pageSize,

package/dist/Helpers/ExcelBackend.d.ts

@@ -43,8 +43,8 @@ export interface ExcelDownloadHeaders {
 export declare abstract class ExcelBackend {
     /** The form field an upload is sent under. */
     abstract get uploadField(): string;
-    /** What an import sends: the rows the verify answered with, as the person left them. */
-    abstract importRequest(rows: readonly ExcelSheetRow[]): unknown;
+    /** What an import sends: the rows the verify answered with, as the person left them, and the status they start in. */
+    abstract importRequest(rows: readonly ExcelSheetRow[], recordStatus?: number): unknown;
     /** What an export sends: the search, the sort and the filters the person has on screen. */
     abstract exportRequest(query: ExcelExportQuery): unknown;
     /** Reads what the settings endpoint answered. */
@@ -67,7 +67,7 @@ export declare abstract class ExcelBackend {
  */
 export declare class NexusExcelBackend extends ExcelBackend {
     get uploadField(): string;
-    importRequest(rows: readonly ExcelSheetRow[]): unknown;
+    importRequest(rows: readonly ExcelSheetRow[], recordStatus?: number): unknown;
     /**
      * The same request a Nexus listing takes, minus `skipCount` and `maxCount`: an export writes every row the search
      * leaves, up to the backend's own limit, not the page the person happens to be on. With nothing sorted it follows

package/dist/Helpers/ExcelBackend.js

@@ -53,8 +53,8 @@ export class NexusExcelBackend extends ExcelBackend {
     get uploadField() {
         return "file";
     }
-    importRequest(rows) {
-        return { rows };
+    importRequest(rows, recordStatus) {
+        return recordStatus === undefined ? { rows } : { rows, recordStatus };
     }
     /**
      * The same request a Nexus listing takes, minus `skipCount` and `maxCount`: an export writes every row the search
@@ -79,6 +79,10 @@ export class NexusExcelBackend extends ExcelBackend {
             maxImportRows: count(answer.maxImportRows, DEFAULT_MAX_IMPORT_ROWS),
             columns: readColumns(answer.columns),
             inputs: Array.isArray(answer.inputs) ? answer.inputs : [],
+            recordStatuses: Array.isArray(answer.recordStatuses)
+                ? answer.recordStatuses.filter(isRecord).flatMap(status => (typeof status.value === "number" && typeof status.label === "string" ? [{ value: status.value, label: status.label }] : []))
+                : [],
+            defaultRecordStatus: typeof answer.defaultRecordStatus === "number" ? answer.defaultRecordStatus : undefined,
         };
     }
     readVerify(result) {
@@ -233,6 +237,8 @@ export function readExcelResponse(body, status) {
                 messageCode: text(first.messageCode) ?? undefined,
                 errorCode: first.errorCode === undefined ? undefined : count(first.errorCode),
                 ...(Object.keys(errors).length ? { errors } : {}),
+                // An import that wrote nothing still says, row by row, what it refused and why (XLS_X044): keep that report.
+                ...(isRecord(body.result) ? { result: body.result } : {}),
             };
         }
     }

package/dist/Helpers/ExcelHelpers.d.ts

@@ -8,11 +8,14 @@ export declare const EXCEL_ROW_NUMBER = "__excelRow";
 export declare const EXCEL_ROW_KEYS = "__excelKeys";
 /** The field of an editor row that holds what the verify answered for it, so an edit can be told from an untouched row. */
 export declare const EXCEL_ROW_SENT = "__excelSent";
-/** One row of a review editor: a value per column, plus the three fields the editor carries for itself. */
+/**
+ * One row of a review editor: a value per column, plus the three fields the editor carries for itself. A row added in
+ * the browser - by Add, Insert or Duplicate, or every row of a bulk insert - has none of the three, or only some.
+ */
 export interface ExcelEditorRow {
-    [EXCEL_ROW_NUMBER]: number;
-    [EXCEL_ROW_KEYS]: Record<string, string | null>;
-    [EXCEL_ROW_SENT]: Record<string, string | null>;
+    [EXCEL_ROW_NUMBER]?: number;
+    [EXCEL_ROW_KEYS]?: Record<string, string | null>;
+    [EXCEL_ROW_SENT]?: Record<string, string | null>;
     [field: string]: unknown;
 }
 declare const DEFAULT_TEXT: {
@@ -25,7 +28,15 @@ declare const DEFAULT_TEXT: {
     readonly verifyFailed: "The file could not be read.";
     readonly newRows: "New rows";
     readonly duplicates: "Already there";
-    readonly duplicateHint: "Nothing here is updated. Edit a row to add it as a new record instead.";
+    readonly duplicateHint: "Already records: these are skipped, and nothing here is updated.";
+    readonly failedHead: "Not written";
+    readonly skippedHead: "Skipped: already there";
+    readonly importAgain: "To import another file, start over.";
+    readonly addAgain: "To add more, start over.";
+    readonly bulkUnavailable: "The sheet's columns could not be read, so there is nothing to type the rows into.";
+    readonly discardTitle: "Discard what you typed?";
+    readonly discardLabel: "Discard";
+    readonly keepEditing: "Keep editing";
     readonly toFix: "What needs fixing";
     readonly whyDuplicate: "Why these are already there";
     readonly referenceLocked: "Picked in the spreadsheet: this list belongs to the server.";
@@ -66,18 +77,35 @@ export declare function isExcelColumnEditable(column: ExcelColumnInfo): boolean;
  * A reference cell shows the **words** the person picked, because its key is not something anybody reads or types.
  */
 export declare function excelEditorRows(rows: readonly ExcelReviewRow[], columns: readonly ExcelColumnInfo[]): ExcelEditorRow[];
+/** The sheet row a row came from, or 0 for a row added in the browser. */
+export declare function excelRowNumber(row: ExcelEditorRow): number;
 /**
  * The editors' rows as rows to send: every value as text, every reference as the key it came with, and the sheet's own
  * row number kept so a problem can still name where it is.
  *
  * A cell the person did not touch goes back **exactly** as it came, which is what makes the round trip faithful: the
  * backend reads its own text again, not a number an input rewrote on the way through.
+ *
+ * A row added in the browser has no sheet row, so it is numbered after the last one the sheet had: no two rows share a
+ * number, and a problem still names the row it is about. `after` is that last row - the file's, rows already there and
+ * rows taken out of the review included, which are not among the rows sent. A bulk insert, with no sheet at all,
+ * numbers its rows 1, 2, 3.
  */
-export declare function excelSheetRows(rows: readonly ExcelEditorRow[], columns: readonly ExcelColumnInfo[]): ExcelSheetRow[];
+export declare function excelSheetRows(rows: readonly ExcelEditorRow[], columns: readonly ExcelColumnInfo[], after?: number): ExcelSheetRow[];
 /** Whether the person changed anything in a row since the verify answered it. */
 export declare function isExcelRowEdited(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
-/** Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). */
-export declare function excelProblemPlace(problem: ExcelCellProblem): string;
+/** Whether a row has anything in a cell the person types in. A row added and left empty has not, and is not sent. */
+export declare function hasExcelValues(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
+/**
+ * Whether a row holds something only this screen has, which closing it would lose: a sheet's row the person edited, or
+ * a row added here with anything in it.
+ */
+export declare function isExcelRowTyped(row: ExcelEditorRow, columns: readonly ExcelColumnInfo[]): boolean;
+/**
+ * Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). Rows
+ * typed in the browser have no sheet, so `byRow` names the row instead ("Row 3 - City name").
+ */
+export declare function excelProblemPlace(problem: ExcelCellProblem, byRow?: boolean): string;
 /** Every problem of these rows, in the order the rows read. */
 export declare function excelProblems(rows: readonly ExcelReviewRow[]): ExcelCellProblem[];
 /** The rows of one kind. */

package/dist/Helpers/ExcelHelpers.js

@@ -1,4 +1,6 @@
 import { ExcelDataType, ExcelRowKind } from "../Interfaces/ExcelInterfaces.js";
+import { toIsoDate } from "./DateHelpers.js";
+import { toIsoTime } from "./TimeHelpers.js";
 /*
  * Turning a sheet's columns into inputs, a verify's rows into editable rows and back, and handing the person a file.
  * Nothing here calls anything: the calls are in Services/ExcelApi.ts.
@@ -28,7 +30,15 @@ const DEFAULT_TEXT = {
     verifyFailed: "The file could not be read.",
     newRows: "New rows",
     duplicates: "Already there",
-    duplicateHint: "Nothing here is updated. Edit a row to add it as a new record instead.",
+    duplicateHint: "Already records: these are skipped, and nothing here is updated.",
+    failedHead: "Not written",
+    skippedHead: "Skipped: already there",
+    importAgain: "To import another file, start over.",
+    addAgain: "To add more, start over.",
+    bulkUnavailable: "The sheet's columns could not be read, so there is nothing to type the rows into.",
+    discardTitle: "Discard what you typed?",
+    discardLabel: "Discard",
+    keepEditing: "Keep editing",
     toFix: "What needs fixing",
     whyDuplicate: "Why these are already there",
     referenceLocked: "Picked in the spreadsheet: this list belongs to the server.",
@@ -159,12 +169,15 @@ export function excelEditorRows(rows, columns) {
 /** Which types are drawn by a number box, whose empty value is `null`. */
 const NUMBER_TYPES = new Set([ExcelDataType.WholeNumber, ExcelDataType.Decimal, ExcelDataType.Amount]);
 /**
- * A cell's text as the input that draws it wants it: a number as a number, a choice unset rather than empty, and
- * everything else as it reads.
+ * A cell's text as the input that draws it wants it: a number as a number, a choice unset rather than empty, a date
+ * and a time as the inputs hold them, and everything else as it reads.
  *
  * The three empties are not interchangeable. A number box is empty at `null`; a **dropdown** given `""` treats it as a
  * value and reports it as one its list no longer offers ("Not found"), so an empty choice has to be left unset; a text
  * or date box is empty at `""`.
+ *
+ * A date and a time are read the way their inputs read them: the sheet's "09:30:00" is the time box's "09:30". Read
+ * any other way, a cell nobody touched would compare as an edit - and the panel would ask before closing over it.
  */
 function toInputValue(column, value) {
     if (value === null || value === "")
@@ -184,6 +197,10 @@ function toInputValue(column, value) {
                 return "No";
             return value;
         }
+        case ExcelDataType.Date:
+            return toIsoDate(value) ?? value;
+        case ExcelDataType.Time:
+            return toIsoTime(value) ?? value;
         default:
             return value;
     }
@@ -210,17 +227,28 @@ function isSameCell(column, current, sent) {
         return true;
     return toInputValue(column, asSheet) === toInputValue(column, sent ?? null);
 }
+/** The sheet row a row came from, or 0 for a row added in the browser. */
+export function excelRowNumber(row) {
+    const number = Number(row[EXCEL_ROW_NUMBER]);
+    return Number.isFinite(number) && number > 0 ? number : 0;
+}
 /**
  * The editors' rows as rows to send: every value as text, every reference as the key it came with, and the sheet's own
  * row number kept so a problem can still name where it is.
  *
  * A cell the person did not touch goes back **exactly** as it came, which is what makes the round trip faithful: the
  * backend reads its own text again, not a number an input rewrote on the way through.
+ *
+ * A row added in the browser has no sheet row, so it is numbered after the last one the sheet had: no two rows share a
+ * number, and a problem still names the row it is about. `after` is that last row - the file's, rows already there and
+ * rows taken out of the review included, which are not among the rows sent. A bulk insert, with no sheet at all,
+ * numbers its rows 1, 2, 3.
  */
-export function excelSheetRows(rows, columns) {
-    return rows.map((row, index) => {
-        const keys = (row[EXCEL_ROW_KEYS] ?? {});
-        const sent = (row[EXCEL_ROW_SENT] ?? {});
+export function excelSheetRows(rows, columns, after = 0) {
+    let next = rows.reduce((last, row) => Math.max(last, excelRowNumber(row)), Math.max(0, after));
+    return rows.map(row => {
+        const keys = row[EXCEL_ROW_KEYS] ?? {};
+        const sent = row[EXCEL_ROW_SENT] ?? {};
         const values = {};
         const labels = {};
         for (const column of columns) {
@@ -231,13 +259,12 @@ export function excelSheetRows(rows, columns) {
             }
             values[column.field] = isSameCell(column, row[column.field], sent[column.field]) ? (sent[column.field] ?? null) : toSheetValue(row[column.field]);
         }
-        const number = Number(row[EXCEL_ROW_NUMBER]);
-        return { number: Number.isFinite(number) && number > 0 ? number : index + 1, values, labels };
+        return { number: excelRowNumber(row) || ++next, values, labels };
     });
 }
 /** Whether the person changed anything in a row since the verify answered it. */
 export function isExcelRowEdited(row, columns) {
-    const sent = (row[EXCEL_ROW_SENT] ?? {});
+    const sent = row[EXCEL_ROW_SENT] ?? {};
     for (const column of columns) {
         if (!isExcelColumnEditable(column))
             continue;
@@ -246,10 +273,25 @@ export function isExcelRowEdited(row, columns) {
     }
     return false;
 }
+/** Whether a row has anything in a cell the person types in. A row added and left empty has not, and is not sent. */
+export function hasExcelValues(row, columns) {
+    return columns.some(column => isExcelColumnEditable(column) && toSheetValue(row[column.field]) !== null);
+}
+/**
+ * Whether a row holds something only this screen has, which closing it would lose: a sheet's row the person edited, or
+ * a row added here with anything in it.
+ */
+export function isExcelRowTyped(row, columns) {
+    return excelRowNumber(row) > 0 ? isExcelRowEdited(row, columns) : hasExcelValues(row, columns);
+}
 /* What is wrong, in the person's words */
-/** Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). */
-export function excelProblemPlace(problem) {
-    return problem.cell ? `${problem.cell} ${String.fromCharCode(183)} ${problem.header}` : problem.header;
+/**
+ * Where a problem is, as the person reads it: the cell, a middle dot, and the column's heading ("B7 - City name"). Rows
+ * typed in the browser have no sheet, so `byRow` names the row instead ("Row 3 - City name").
+ */
+export function excelProblemPlace(problem, byRow = false) {
+    const place = byRow ? `Row ${problem.row}` : problem.cell;
+    return place ? `${place} ${String.fromCharCode(183)} ${problem.header}` : problem.header;
 }
 /** Every problem of these rows, in the order the rows read. */
 export function excelProblems(rows) {

package/dist/Helpers/FormStore.d.ts

@@ -25,7 +25,7 @@ export interface FormStatus {
     changed: boolean;
     /** A submit is running. */
     submitting: boolean;
-    /** The values are loading: the inputs show placeholders. */
+    /** The values are loading: the inputs show, disabled, and take nothing typed until the values are in. */
     loading: boolean;
     /** A submit ran and found problems: every message shows. */
     showAll: boolean;
@@ -85,6 +85,8 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     private draftSeq;
     /** The user cancelled: no draft is written until they change a value again. */
     private draftDropped;
+    /** An input reported a value while the values loaded and was refused: it is drawn again from the store when loading ends. */
+    private refusedWhileLoading;
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     private quiet;
     private unannounced;
@@ -137,13 +139,15 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
      * Loads values, such as a record from a server. They become the values the form compares with, and every input shows
      * them. With `keepChanged`, the values the user changed stay (a refresh that merges): only the others change, and the
      * names returned are the changed values whose loaded ones also changed, so the page can say so. `draft: false` leaves
-     * a saved draft for a later load (the form's placeholders show while the real values load). `quiet` tells no listener
-     * until `announce()`, for a load during a render.
+     * a saved draft for a later load (the form shows disabled while the real values load). `quiet` tells no listener
+     * until `announce()`, for a load during a render. `loading` opens the form loading, so whatever reads its status in
+     * the same render — a `FormButtons` after it — draws its loading state from the first frame, on the server too.
      */
-    load(values?: Partial<TValues>, { keepChanged, draft, quiet }?: {
+    load(values?: Partial<TValues>, { keepChanged, draft, quiet, loading }?: {
         keepChanged?: boolean;
         draft?: boolean;
         quiet?: boolean;
+        loading?: boolean;
     }): string[];
     /** Tells listeners about a quiet load. */
     announce(): void;
@@ -197,7 +201,7 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     commit(saved: TValues, extra?: Partial<TValues>): void;
     /** @internal A save after which the form went back to its opening values (`resetOnSuccess`). */
     markSaved(): void;
-    /** @internal */
+    /** @internal While the values load, nothing typed is taken (`input`), and a submit waits (`SubmitForm`). */
     setLoading(loading: boolean): void;
     /** @internal */
     setFormId(formId: string | null): void;

package/dist/Helpers/FormStore.js

@@ -70,6 +70,8 @@ export class FormStore {
     draftSeq = 0;
     /** The user cancelled: no draft is written until they change a value again. */
     draftDropped = false;
+    /** An input reported a value while the values loaded and was refused: it is drawn again from the store when loading ends. */
+    refusedWhileLoading = false;
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     quiet = false;
     unannounced = false;
@@ -216,14 +218,18 @@ export class FormStore {
      * Loads values, such as a record from a server. They become the values the form compares with, and every input shows
      * them. With `keepChanged`, the values the user changed stay (a refresh that merges): only the others change, and the
      * names returned are the changed values whose loaded ones also changed, so the page can say so. `draft: false` leaves
-     * a saved draft for a later load (the form's placeholders show while the real values load). `quiet` tells no listener
-     * until `announce()`, for a load during a render.
+     * a saved draft for a later load (the form shows disabled while the real values load). `quiet` tells no listener
+     * until `announce()`, for a load during a render. `loading` opens the form loading, so whatever reads its status in
+     * the same render — a `FormButtons` after it — draws its loading state from the first frame, on the server too.
      */
-    load(values = {}, { keepChanged = false, draft = true, quiet = false } = {}) {
+    load(values = {}, { keepChanged = false, draft = true, quiet = false, loading } = {}) {
         this.quiet = quiet;
         this.unannounced ||= quiet;
         try {
-            return this.loadValues(values, keepChanged, draft);
+            const changed = this.loadValues(values, keepChanged, draft);
+            if (loading !== undefined)
+                this.patchStatus({ loading });
+            return changed;
         }
         finally {
             this.quiet = false;
@@ -264,8 +270,10 @@ export class FormStore {
                     this.nextRevision(params.name);
         }
         else {
+            // Every input mounts again with its loaded value, one that was typed in while loading included.
             this.generation++;
             this.touched.clear();
+            this.refusedWhileLoading = false;
         }
         this.serverErrors.clear();
         this.serverMessage = null;
@@ -321,6 +329,12 @@ export class FormStore {
     input(name, value, stamp) {
         if (stamp !== this.stamp(name))
             return;
+        // Nothing is taken while the values load, not even from an input whose `disabled` was taken off by hand: the
+        // loaded values would land on top of it, and a change to a record that is not there yet means nothing.
+        if (this.status.loading) {
+            this.refusedWhileLoading = true;
+            return;
+        }
         this.change([[name, value]], "input");
     }
     /** Marks an input as left by the user: the form's rule messages on it show from now on. */
@@ -481,8 +495,14 @@ export class FormStore {
     markSaved() {
         this.patchStatus({ submitting: false, savedAt: Date.now() });
     }
-    /** @internal */
+    /** @internal While the values load, nothing typed is taken (`input`), and a submit waits (`SubmitForm`). */
     setLoading(loading) {
+        // Something was typed and refused, and no load has drawn the inputs again since: they show the store's values.
+        if (!loading && this.refusedWhileLoading) {
+            this.refusedWhileLoading = false;
+            this.generation++;
+            this.bumpAll();
+        }
         this.patchStatus({ loading });
     }
     /** @internal */

package/dist/Helpers/MessageBuilder.js

@@ -43,6 +43,7 @@ const DEFAULT_TEXTS = {
     confirmDetails: {
         delete: "This cannot be undone.",
         trash: "It can be restored from the trash.",
+        recover: "It goes back to the active list.",
     },
     reasons: {
         network: "The server cannot be reached. Check your internet connection and try again.",

package/dist/Helpers/NumberHelpers.d.ts

@@ -1,4 +1,5 @@
 import type { NumberFormatOptions } from "../Interfaces/InputInterfaces.ts";
+import { ENumberScales, type ThousandsSeparator } from "../Interfaces/PreferenceInterfaces.ts";
 /** Default locale for number text. Fixed rather than the browser's, so server-rendered text matches the browser's. */
 export declare const DEFAULT_NUMBER_LOCALE = "en-US";
 /** Most digits a number field takes. A JavaScript number holds 15 significant digits exactly; beyond that, digits change. */
@@ -15,7 +16,12 @@ export interface NumberTextRules {
     /** Allows a leading minus sign. */
     negative: boolean;
 }
-/** The decimal and group separators of a locale. */
+/**
+ * The locale for a number scale and a thousands separator: `en-US` (1,234,567.5) and `en-IN` (12,34,567.5) as they are,
+ * else a key such as "en-US|.|," (1.234.567,5) that `formatNumber`, `parseNumber` and `getNumberSymbols` read.
+ */
+export declare function numberLocale(scale: ENumberScales, thousands: ThousandsSeparator): string;
+/** The decimal and group separators of a locale (or of a key from `numberLocale`). */
 export declare function getNumberSymbols(locale?: string): NumberSymbols;
 /**
  * Formats a number for display: `formatNumber(1250, { decimals: 2, fixedDecimals: true, grouping: true })` gives "1,250.00".