nexus-shared 3.1.0 → 3.2.0

package/dist/Helpers/UserPreferences.d.ts

@@ -1,3 +1,4 @@
+import type { InputDesign } from "../Interfaces/InputInterfaces.ts";
 import { type UserPreferences } from "../Interfaces/PreferenceInterfaces.ts";
 /** The saved settings, with the defaults for anything missing or invalid. Safe to call on the server. */
 export declare function readUserPreferences(): UserPreferences;
@@ -12,3 +13,10 @@ export declare function useUserPreferences(): UserPreferences;
  * use when they are given no `locale` of their own.
  */
 export declare function useNumberLocale(): string;
+/**
+ * The design an input takes: its own (its page's or its form's), else the person's choice in the quick preferences,
+ * else `standard`. A grid's cells and a demo of the designs name theirs, so they keep it. An input with no label of its
+ * own - a table's search box, a picker named by a heading above it - has no label to place, so the choice passes it by:
+ * a design for one would only leave an empty strip where the label would be.
+ */
+export declare function useInputDesign(own: InputDesign | undefined, labelled?: boolean): InputDesign;

package/dist/Helpers/UserPreferences.js

@@ -11,6 +11,7 @@ import { numberLocale } from "./NumberHelpers.js";
 const listeners = new Set();
 let snapshot = DEFAULT_USER_PREFERENCES;
 const SEPARATORS = ["comma", "period", "space", "none"];
+const INPUT_DESIGNS = ["standard", "outlined", "inbox"];
 function read(key) {
     try {
         return localStorage.getItem(key);
@@ -28,12 +29,14 @@ export function readUserPreferences() {
     const thousands = read(PREFERENCE_STORAGE_KEYS.thousands);
     const pageSize = Number(read(PREFERENCE_STORAGE_KEYS.pageSize));
     const rowClick = read(PREFERENCE_STORAGE_KEYS.rowClick);
+    const inputDesign = read(PREFERENCE_STORAGE_KEYS.inputDesign);
     const next = {
         language: language === "ne" ? "ne" : DEFAULT_USER_PREFERENCES.language,
         numberScale: scale === ENumberScales.SouthAsian ? ENumberScales.SouthAsian : DEFAULT_USER_PREFERENCES.numberScale,
         thousands: thousands && SEPARATORS.includes(thousands) ? thousands : DEFAULT_USER_PREFERENCES.thousands,
         pageSize: Number.isInteger(pageSize) && pageSize > 0 ? pageSize : DEFAULT_USER_PREFERENCES.pageSize,
         rowClick: rowClick === "1" ? true : rowClick === "0" ? false : DEFAULT_USER_PREFERENCES.rowClick,
+        inputDesign: inputDesign && INPUT_DESIGNS.includes(inputDesign) ? inputDesign : DEFAULT_USER_PREFERENCES.inputDesign,
     };
     // The same object while nothing changed, so React sees a stable snapshot.
     const keys = Object.keys(next);
@@ -59,6 +62,10 @@ export function setUserPreferences(changes) {
             localStorage.removeItem(PREFERENCE_STORAGE_KEYS.rowClick);
         else if (changes.rowClick !== undefined)
             localStorage.setItem(PREFERENCE_STORAGE_KEYS.rowClick, changes.rowClick ? "1" : "0");
+        if (changes.inputDesign === null)
+            localStorage.removeItem(PREFERENCE_STORAGE_KEYS.inputDesign);
+        else if (changes.inputDesign !== undefined)
+            localStorage.setItem(PREFERENCE_STORAGE_KEYS.inputDesign, changes.inputDesign);
     }
     catch {
         // Storage blocked (private mode, for example): the components keep what they have.
@@ -97,3 +104,13 @@ export function useNumberLocale() {
     const { numberScale, thousands } = useUserPreferences();
     return numberLocale(numberScale, thousands);
 }
+/**
+ * The design an input takes: its own (its page's or its form's), else the person's choice in the quick preferences,
+ * else `standard`. A grid's cells and a demo of the designs name theirs, so they keep it. An input with no label of its
+ * own - a table's search box, a picker named by a heading above it - has no label to place, so the choice passes it by:
+ * a design for one would only leave an empty strip where the label would be.
+ */
+export function useInputDesign(own, labelled = true) {
+    const chosen = useSyncExternalStore(subscribeUserPreferences, () => readUserPreferences().inputDesign, () => DEFAULT_USER_PREFERENCES.inputDesign);
+    return own ?? (labelled ? chosen : null) ?? "standard";
+}

package/dist/Interfaces/CrudInterfaces.d.ts

@@ -2,6 +2,7 @@ import type { CSSProperties, ReactNode, Ref } from "react";
 import type { PopupSize } from "../Components/Layouts/Popup.tsx";
 import type { PopupHandle } from "../Components/Layouts/PopupHost.tsx";
 import type { FormStore } from "../Helpers/FormStore.ts";
+import type { CrudBackend } from "../Helpers/CrudBackend.ts";
 import type { TableStore } from "../Helpers/TableStore.ts";
 import type { ApiEndpoint } from "./ApiInterfaces.ts";
 import type { FormProps, FormValues, InputParams } from "./FormInterfaces.ts";
@@ -9,14 +10,19 @@ 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 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.
+ * (which can go back to the trash). The records the user pinned or made favourites are not lists of their own: they
+ * sit in sections above the active list, and in it.
  */
 export type CrudMode = "normal" | "flag" | "trash" | "deleted";
 /** The built-in actions on one record. */
-export type CrudRowActionName = "view" | "edit" | "flag" | "pin" | "trash" | "recover" | "delete" | "trashFromDelete";
+export type CrudRowActionName = "view" | "edit" | "flag" | "pin" | "favorite" | "history" | "trash" | "recover" | "delete" | "trashFromDelete";
 /** The built-in actions on many records at once. */
-export type CrudMassActionName = "flag" | "pin" | "trash" | "recover" | "delete" | "trashFromDelete" | "description";
+export type CrudMassActionName = "flag" | "pin" | "favorite" | "trash" | "recover" | "delete" | "trashFromDelete" | "description";
+/**
+ * A mark a user puts on a record for themselves: pinned, or one of their favourites. Each has a section above the
+ * active list and its own limit, and a record may carry both.
+ */
+export type CrudMark = "pin" | "favorite";
 /** Every built-in action: Add, the row actions, and a new description for many records. */
 export type CrudActionName = "create" | CrudRowActionName | "description";
 /**
@@ -29,8 +35,15 @@ export interface CrudEndpoints {
     /** One page of a list, for tables that page on the server: `Room/NormalPagination`, … */
     pages?: Partial<Record<CrudMode, ApiEndpoint>>;
     /**
-     * The records the user pinned: `Room/PinListing`. They show in a section above the active list, which the user folds
-     * open, and in the list itself. Without it there is no pinned section, and nothing counts the pins against the limit.
+     * This user's marked records, pins and favourites in one list: `Room/BookmarkListing`. Each record says which marks
+     * it has (`CrudBackend.marksOf`), and the CRUD splits them into the Pinned and Favourites sections above the active
+     * list. It is also where the CRUD learns every record's marks, so a list's own rows need not carry them. Without it
+     * (or `pins`) there are no sections, and nothing counts the marks against their limits.
+     */
+    bookmarks?: ApiEndpoint;
+    /**
+     * The records the user pinned, from a backend that keeps no favourites: `Room/PinListing`. A Pinned section and no
+     * Favourites. `bookmarks` wins when both are given.
      */
     pins?: ApiEndpoint;
     /** One record by its key: `{id}` in the path. */
@@ -38,14 +51,34 @@ export interface CrudEndpoints {
     create?: ApiEndpoint;
     update?: ApiEndpoint;
     flag?: ApiEndpoint;
-    /** Pins a record, or unpins it: `Room/Pin/{id}`. */
+    /**
+     * Sets this user's marks on a record: `Room/SwitchBookmarks/{id}`, sent the whole set the record is to have, never a
+     * toggle (`CrudBackend.marksRequest`). Pin and Favourite both use it.
+     */
+    bookmark?: ApiEndpoint;
+    /** Pins a record or unpins it, on a backend without `bookmark`: `Room/Pin/{id}`, a toggle. `bookmark` wins when both are given. */
     pin?: ApiEndpoint;
+    /**
+     * A record's history, 50 entries a call: `Room/AuditListing/{ownerId}/{skipCount}`. With it every row offers History
+     * and the details View history, to a person who may call it.
+     */
+    audit?: ApiEndpoint;
     trash?: ApiEndpoint;
     recover?: ApiEndpoint;
     delete?: ApiEndpoint;
     trashFromDelete?: ApiEndpoint;
-    /** Actions on many records, sent the selected keys. */
-    mass?: Partial<Record<CrudMassActionName, ApiEndpoint>>;
+    /**
+     * Actions on many records, sent the selected keys. `bookmark` puts one mark on every record sent or takes it off, and
+     * leaves their other marks alone (`Room/MassSwitchBookmarks`): Pin and Favourite both use it, and it wins over `pin`.
+     */
+    mass?: Partial<Record<Exclude<CrudMassActionName, "favorite"> | "bookmark", ApiEndpoint>>;
+    /**
+     * Where other pages look this controller's records up: by key (`Room/FindListing`, a table's client join and a
+     * picker's saved values) and as a picker's list (`Room/ActiveListing`). The CRUD calls neither; a change it makes marks
+     * what was looked up through them as old, so a name or a status shown elsewhere is read again.
+     */
+    findListing?: ApiEndpoint;
+    activeListing?: ApiEndpoint;
 }
 /** Inputs of the Add and Edit forms: one list for both, a list for each, or a function of the action and the row. */
 export type CrudInputs<TRow extends FormValues = FormValues> = readonly InputParams[] | {
@@ -206,6 +239,11 @@ export interface CrudProps<TRow extends FormValues = FormValues> {
     table?: CrudTableOptions<TRow>;
     /** After every change the CRUD made: a record added, saved, trashed, deleted. */
     onChange?: (change: CrudChange<TRow>) => void;
+    /**
+     * The conventions of this controller's backend, when they differ from the app's (`defineCrudBackend`): an app whose
+     * pages sit on two backends gives the other one here. Default the app's, else the Nexus backend's.
+     */
+    backend?: CrudBackend;
     /** The table's name for screen readers. Default: the plural of the subject ("Guests"). */
     "aria-label"?: string;
     "aria-labelledby"?: string;

package/dist/Interfaces/FormInterfaces.d.ts

@@ -1,6 +1,7 @@
 import type { CSSProperties, ReactNode, Ref } from "react";
 import type { CheckBoxOnlyProps, CheckBoxProps } from "../Components/Inputs/CheckBox.tsx";
 import type { CheckBoxGroupProps } from "../Components/Inputs/CheckBoxGroup.tsx";
+import type { CodeBoxProps } from "../Components/Inputs/CodeBox.tsx";
 import type { DatePickerProps } from "../Components/Inputs/DatePicker.tsx";
 import type { DateRangePickerProps } from "../Components/Inputs/DateRangePicker.tsx";
 import type { DateTimePickerProps } from "../Components/Inputs/DateTimePicker.tsx";
@@ -63,6 +64,8 @@ export type InputParamsOf<TType extends string, TProps> = DistributiveOmit<TProp
 export type TextInputParams = InputParamsOf<TextBoxType, TextBoxProps>;
 export type TextAreaParams = InputParamsOf<"textarea", TextAreaProps>;
 export type NumberInputParams = InputParamsOf<"number", NumberBoxProps>;
+/** `CodeBox`: a box per character. The value is the code's characters, without separators. */
+export type CodeInputParams = InputParamsOf<"code", CodeBoxProps>;
 /** A checkbox: `true` or `false`. `defaultChecked` is the value of a new row. */
 export type CheckBoxParams = InputParamsOf<"checkbox", CheckBoxProps & CheckBoxOnlyProps>;
 export type SwitchParams = InputParamsOf<"switch", CheckBoxProps>;
@@ -90,7 +93,7 @@ export type TabularParams = InputParamsOf<"tabular", TabularFormProps>;
 /** `GroupForm`: the same rows, each as a section of inputs. */
 export type GroupParams = InputParamsOf<"group", GroupFormProps>;
 /** The params of any input: the root type every form takes as `inputs`. */
-export type InputParams = TextInputParams | TextAreaParams | NumberInputParams | CheckBoxParams | SwitchParams | RadioParams | CheckBoxGroupParams | RadioGroupParams | DropdownParams | DateParams | DateRangeParams | TimeParams | DateTimeParams | SliderParams | RangeSliderParams | MarkdownParams | RichTextParams | TreeParams | TabularParams | GroupParams;
+export type InputParams = TextInputParams | TextAreaParams | NumberInputParams | CodeInputParams | CheckBoxParams | SwitchParams | RadioParams | CheckBoxGroupParams | RadioGroupParams | DropdownParams | DateParams | DateRangeParams | TimeParams | DateTimeParams | SliderParams | RangeSliderParams | MarkdownParams | RichTextParams | TreeParams | TabularParams | GroupParams;
 export type InputType = InputParams["type"];
 /** Settings a check needs to write its message the way the field shows values: the user's date and time settings. */
 export interface InputValidationContext {

package/dist/Interfaces/InputInterfaces.d.ts

@@ -31,6 +31,30 @@ export interface TextRules {
     /** Runs after the built-in rules pass. */
     validate?: TextValidator;
 }
+/**
+ * What a code box takes, one character to a box:
+ * - `digits`: 0–9, with the phone's number pad. A one-time code, a PIN, an SSN.
+ * - `letters`: A–Z.
+ * - `alphanumeric`: letters and digits, such as a licence key or a booking reference.
+ * - `hex`: 0–9 and A–F, such as a colour or a device id.
+ */
+export type CodeCharacters = "digits" | "letters" | "alphanumeric" | "hex";
+/** The shape and rules of a code: how many boxes, in which groups, and what each box takes. Plain values, so params stay serializable. */
+export interface CodeRules {
+    /** How many boxes. Default 6. Left out when `groups` is given. */
+    length?: number;
+    /** Boxes in groups, with a gap or a `separator` between them: `[3, 2, 4]` for an SSN, `[3, 3]` for a one-time code. */
+    groups?: readonly number[];
+    /** Default `digits`. */
+    characters?: CodeCharacters;
+    /** A regular expression for one character, in place of `characters`: `"[A-HJ-NP-Z2-9]"` leaves out I, O, 0 and 1. */
+    allowed?: string;
+    /** Letters as typed are turned to this case. Default `upper`; `any` keeps them as typed. */
+    letterCase?: "upper" | "lower" | "any";
+    required?: boolean;
+    /** Runs after the built-in rules pass, with the code. */
+    validate?: TextValidator;
+}
 /** Custom check for a number. Receives the value, or `null` when the field is empty; returns a message to fail. */
 export type NumberValidator = (value: number | null) => string | null | undefined;
 /** Validation rules for a number, named like the HTML attributes. */

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" | "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" | "favorite" | "unfavorite" | "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/PreferenceInterfaces.d.ts

@@ -1,3 +1,4 @@
+import type { InputDesign } from "./InputInterfaces.ts";
 /** The words of the app itself. Data keeps the language it was entered in. */
 export type InterfaceLanguage = "en" | "ne";
 /**
@@ -31,6 +32,12 @@ export interface UserPreferences {
      * the table says itself. `null` (the default): not chosen, each table's own `openOnClick`.
      */
     rowClick: boolean | null;
+    /**
+     * The design every input takes when its page or form names none: the label above the box (`standard`), on its edge
+     * (`outlined`) or inside its top (`inbox`). `null` (the default): not chosen, `standard`. An input whose page fixes a
+     * design - a grid's cells, a demo of the designs - keeps it.
+     */
+    inputDesign: InputDesign | null;
 }
 export declare const DEFAULT_USER_PREFERENCES: UserPreferences;
 /** Local storage keys of the settings. A number scale is kept as its member value ("0", "1"), a row click as "1" or "0". */
@@ -40,4 +47,5 @@ export declare const PREFERENCE_STORAGE_KEYS: {
     readonly thousands: "nx-thousands";
     readonly pageSize: "nx-page-size";
     readonly rowClick: "nx-row-click";
+    readonly inputDesign: "nx-input-design";
 };

package/dist/Interfaces/PreferenceInterfaces.js

@@ -1,8 +1,3 @@
-/*
- * The person's own settings beyond the theme and the dates: the interface language, how numbers are written, and what a
- * table does before anyone touches its own controls. Saved on this device and read by the components that show them,
- * so a change applies to everything on the page at once. The date settings are `DatePreferences` (DateInterfaces.ts).
- */
 /**
  * The core's `ENumberScales`, by member value: where the groups of a number fall. `International` writes 1,234,567
  * (thousand, million, billion); `SouthAsian` writes 12,34,567 (thousand, lakh, crore).
@@ -17,6 +12,7 @@ export const DEFAULT_USER_PREFERENCES = {
     thousands: "comma",
     pageSize: null,
     rowClick: null,
+    inputDesign: null,
 };
 /** Local storage keys of the settings. A number scale is kept as its member value ("0", "1"), a row click as "1" or "0". */
 export const PREFERENCE_STORAGE_KEYS = {
@@ -25,4 +21,5 @@ export const PREFERENCE_STORAGE_KEYS = {
     thousands: "nx-thousands",
     pageSize: "nx-page-size",
     rowClick: "nx-row-click",
+    inputDesign: "nx-input-design",
 };

package/dist/Interfaces/TableInterfaces.d.ts

@@ -1,5 +1,7 @@
+import type { IconNode } from "nexus-icons";
 import type { CSSProperties, ReactNode, Ref } from "react";
 import type { TableStore } from "../Helpers/TableStore.ts";
+import type { ApiEndpoint } from "./ApiInterfaces.ts";
 import type { ExcelEndpoints } from "./ExcelInterfaces.ts";
 import type { InputParams } from "./FormInterfaces.ts";
 import type { Size, Tone } from "./TypeInterfaces.ts";
@@ -16,6 +18,11 @@ export interface TableColumnOption {
     /** Draws the value as a tag with a dot of this color. */
     tone?: Tone;
 }
+/** A short tag after a cell's value (`TableColumn.tag`): its words and the color of its dot. */
+export interface TableTag {
+    label: string;
+    tone?: Tone;
+}
 /** One column: which field it shows, how, and what the user can do with it. */
 export interface TableColumn<TRow extends TableRow = TableRow> {
     /** The field: `"name"`, or a path into the row, `"guest.name"`. It is also the column's id and its sort name. */
@@ -65,6 +72,8 @@ export interface TableColumn<TRow extends TableRow = TableRow> {
     hideable?: boolean;
     /** Long text wraps onto more lines instead of ending in "…". */
     wrap?: boolean;
+    /** Its text is Markdown: the table shows the text, and a record's details show it formatted. */
+    markdown?: boolean;
     /** The user can drag the heading to another place, or move it from its menu. Default true. */
     movable?: boolean;
     /** The user can drag the edge of the heading to change the width. Default true; `false` for a column that must keep its width. */
@@ -73,6 +82,44 @@ export interface TableColumn<TRow extends TableRow = TableRow> {
     pinnable?: boolean;
     /** Pinned before the user pins anything: `left` keeps it at the start, `right` at the end. */
     pinned?: TablePinSide;
+    /**
+     * The value is another record's, looked up by the key this row holds: a country's sub-region named from the
+     * sub-regions' `FindListing`. The table collects every key its rows hold, asks once for the ones it has not got, keeps
+     * the answers for every table on the page, and shows the field once they are in - searched and sorted like any other
+     * column. A key the source does not answer shows as "Not found". (A join the database already made needs none of
+     * this: the row carries the name, and `tag` reads its status.)
+     */
+    join?: TableJoin;
+    /**
+     * A short tag after the value: "Trashed" beside a parent that is in the trash. Given the row and, on a `join` column,
+     * the record it looked up; nothing when it answers nothing. `crudColumns.dbJoin` and `crudColumns.clientJoin` set it.
+     */
+    tag?: (row: TRow, joined?: TableJoinedRecord) => TableTag | null | undefined;
+}
+/** A record a `join` looked up: whatever its source answers for one key. */
+export type TableJoinedRecord = Readonly<Record<string, unknown>>;
+/** Where a `join` looks records up: the records behind a set of keys, in any status. */
+export interface TableJoinSource {
+    /** One name per source. Every column and table that names it shares its answers and its calls. */
+    readonly name: string;
+    /** The records behind these keys; a key with no record is left out. One call for every key the page needs at once. */
+    load(keys: readonly string[], signal: AbortSignal): Promise<readonly TableJoinedRecord[]>;
+    /** The field of a loaded record that holds its key. Default `id`. */
+    readonly key?: string;
+    /** How long an answer is kept, in milliseconds, before it is asked again. Default 5 minutes. */
+    readonly lifetime?: number;
+}
+/** A column whose value is another record's (`TableColumn.join`). */
+export interface TableJoin {
+    /** The field of this row that holds the other record's key: `"subRegionId"`. */
+    from: string;
+    /** The field of the other record the column shows. Default: the column's own `key`. */
+    field?: string;
+    /**
+     * Where the records come from: an endpoint the keys are POSTed to as an array (a Nexus controller's `findListing`),
+     * or a source of the page's own.
+     */
+    source: ApiEndpoint | TableJoinSource;
 }
 /** Which side a pinned column stays on while the others scroll. */
 export type TablePinSide = "left" | "right";
@@ -212,6 +259,30 @@ export interface TableMenuAction {
     separator?: boolean;
     onSelect: () => void;
 }
+/**
+ * Rows kept in a section above the page, which the user folds open and shut: the records they pinned, their
+ * favourites. They are the rows as they came from their own endpoint, the same records also show in the list below,
+ * and each section's row wears the section's icon where the rows of the page show their number.
+ */
+export interface TableRowSection<TRow extends TableRow = TableRow> {
+    /** Tells the sections apart; the table remembers each one's fold under it. */
+    key: string;
+    /** What the section is called: "Pinned rooms". */
+    label: string;
+    /** The section's icon, in its head and on each of its rows. */
+    icon: IconNode;
+    rows: readonly TRow[];
+    /** The rows are on their way: the section shows that it is loading. */
+    loading?: boolean;
+    /** Most rows the section can hold, shown beside the count so the user knows the limit. */
+    max?: number;
+}
+/** A mark a row carries for this user - pinned, a favourite - drawn in its first column where its number would be. */
+export interface TableRowMark {
+    icon: IconNode;
+    /** What the mark says: "Pinned". */
+    label: string;
+}
 /** A way to select rows by what they are, such as "Pinned" or "Not flagged". */
 export interface TableSelectBy<TRow extends TableRow = TableRow> {
     label: string;
@@ -340,8 +411,19 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
      */
     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.
+     * Sections above the page, in this order, each folding open and shut on its own: the records the user pinned, then
+     * their favourites. A section with no rows and none on their way does not show.
+     */
+    sections?: readonly TableRowSection<TRow>[];
+    /**
+     * The marks each row carries (pinned, a favourite), in its first column in place of its number, one under the
+     * other - in the list and in the sections alike, so no column of their own is needed. A row with none shows its
+     * number; a section's row with none shows the section's icon.
+     */
+    rowMarks?: (row: TRow) => readonly TableRowMark[];
+    /**
+     * One section of pinned rows, before any `sections`: the same as a section with the key `pins` and the pin icon.
+     * Leave it out for no such section.
      */
     pinnedRows?: readonly TRow[];
     /** The pinned rows are on their way: the section shows that it is loading. */
@@ -361,8 +443,8 @@ export interface DataTableProps<TRow extends TableRow = TableRow> {
      * as the pointer is over the row or anything is selected.
      */
     numbered?: boolean;
-    /** Remembers the page size, the sort, hidden columns, the order, widths, and pins of the columns, and whether the
-     * pinned section is open, on this device. */
+    /** Remembers the page size, the sort, hidden columns, the order, widths, and pins of the columns, and which sections
+     * are open, on this device. */
     stateKey?: string;
     /** Milliseconds after the last key before a search goes to a server. Default 300; a table with every row searches at once. */
     searchDelay?: number;

package/dist/Services/ApiProxy.d.ts

@@ -1,4 +1,6 @@
 import type { ApiModuleValue } from "../Interfaces/ApiInterfaces.ts";
+import { type ApiProxyCode, type ApiProxyFailure } from "./ApiProxyRules.ts";
+export { DEFAULT_PROXY_BODY_LIMIT, DEFAULT_PROXY_REDIRECTS, DEFAULT_PROXY_RESPONSE_HEADERS, lastForwardedAddress, nexusFailure, PROXY_REFUSALS, readIpAddress, type ApiProxyCode, type ApiProxyFailure } from "./ApiProxyRules.ts";
 export interface ApiProxyOptions {
     /** The user's token for the backend, such as from the session cookie. Without one, the request's own Authorization header goes on. */
     token?: (request: Request) => string | null | undefined | Promise<string | null | undefined>;
@@ -6,10 +8,34 @@ export interface ApiProxyOptions {
     headers?: (request: Request) => Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
     /** Serves only these modules, of those the app's `ApiModules` sends through the proxy. Default: all of those. */
     allow?: readonly ApiModuleValue[];
-    /** Milliseconds to wait for the backend to start answering. Default 60,000. */
+    /** Milliseconds to wait for the backend to start answering, its redirects included. Default 60,000. */
     timeout?: number;
     /** The `fetch` to use. Default: the global one. */
     fetch?: typeof fetch;
+    /**
+     * More of the backend's response headers to pass on, besides `DEFAULT_PROXY_RESPONSE_HEADERS` and the Nexus backend's
+     * own `X-Nexus-*`: `["X-Total-Count"]`. A header that names the backend or carries its own policies (Server,
+     * X-Powered-By, X-AspNet-*, Via, Alt-Svc, Strict-Transport-Security, CORS, Location, Link) is dropped even when named.
+     */
+    responseHeaders?: readonly string[];
+    /** Passes the backend's Set-Cookie headers to the browser. Default false: the app keeps its own session. */
+    passCookies?: boolean;
+    /** The most bytes a request body may have; a bigger one is refused with 413 before it reaches the backend. Default 100 MB. */
+    maxBodySize?: number;
+    /** How many redirects inside a module to follow for one call; 0 refuses every redirect. Default 3. */
+    maxRedirects?: number;
+    /**
+     * The client's IP address, sent to the backend as X-Forwarded-For for its sign-in lockout and rate limits. Default:
+     * the last address of the X-Forwarded-For the app received, the one Next.js or the app's own reverse proxy wrote. Pass
+     * it behind more than one proxy of the app's own, or behind a CDN that names the client in a header of its own.
+     */
+    clientAddress?: (request: Request) => string | null | undefined | Promise<string | null | undefined>;
+    /** Lets pages of other sites call through the proxy. Default false: the app's own pages, links followed, and non-browser callers. */
+    allowCrossSite?: boolean;
+    /** Builds the answer to a refusal of the proxy's own, for a backend whose envelope is not Nexus's. Default `nexusFailure`. */
+    failure?: (failure: ApiProxyFailure) => Response;
+    /** Hears what the proxy hid or refused, on the server. Default: one line in `console.error`. */
+    onProblem?: (problem: ApiProxyProblem) => void;
 }
 /** What a Next.js route handler for `[module]/[...path]` receives. */
 export interface ApiProxyContext {
@@ -18,6 +44,15 @@ export interface ApiProxyContext {
         path?: string[];
     }>;
 }
+/** What the proxy hid or refused, for the server's log. It never holds the user's token or a query string. */
+export interface ApiProxyProblem {
+    /** The refusal's code, the one the browser got: "BACKEND_REDIRECT_REFUSED". */
+    messageCode: ApiProxyCode;
+    /** The call, as the browser made it: "POST configuration/Region/MassRecover". */
+    call: string;
+    /** What happened, for a developer: the backend's address and status, a piece of its error page, why it failed. */
+    detail: string;
+}
 /**
  * Makes the route handlers of the proxy. Only the modules' configured roots can be reached: a path cannot climb out of
  * its module (`..` is refused), and the query goes on unchanged.