nexus-shared 4.0.0 → 4.1.0

package/dist/Interfaces/DashboardInterfaces.d.ts

@@ -0,0 +1,123 @@
+import type { ReactNode } from "react";
+/**
+ * A widget's size on the board's 12-column grid: `S` 3×1, `M` 6×2, `L` 6×4, `W` 12×2, `T` 12×4 (columns × rows).
+ * Presets rather than free resizing: fewer layouts that look broken, and nothing to work out on a phone, where every
+ * widget is the full width.
+ */
+export type WidgetSize = "S" | "M" | "L" | "W" | "T";
+/** Where a widget may go: `own` only on its module's dashboard, `anywhere` on any dashboard (the Home too). */
+export type WidgetPlacement = "own" | "anywhere";
+/** One widget on a board: which, and how big. A layout is an ordered list of these: no coordinates are kept. */
+export interface DashboardLayoutItem {
+    code: string;
+    size: WidgetSize;
+}
+/** A board's layout: the widgets in the order they flow, the grid filling every gap (`grid-auto-flow: dense`). */
+export type DashboardLayout = readonly DashboardLayoutItem[];
+/** The version a saved layout carries, so two windows never overwrite each other unseen. */
+export type DashboardVersion = string | number | null;
+/**
+ * What a save (or a reset) answered. `saved` with the new version; `stale` when another window saved first (the
+ * server's 409): its layout and version, which the board shows in place of the edit; `failed` with a sentence.
+ */
+export type DashboardSaveResult = {
+    status: "saved";
+    version: DashboardVersion;
+    layout?: DashboardLayout;
+} | {
+    status: "stale";
+    layout: DashboardLayout;
+    version: DashboardVersion;
+} | {
+    status: "failed";
+    message?: string;
+};
+/** What a widget's `load` and `render` are told. */
+export interface WidgetContext {
+    /** The board's place (`home`, `message`, ...). */
+    place: string;
+    /** The size it is drawn at. */
+    size: WidgetSize;
+}
+/** What a widget's `render` is told besides its data. */
+export interface WidgetRenderContext extends WidgetContext {
+    /** Reads the widget's data again now. */
+    refresh: () => void;
+}
+/**
+ * A widget answered by its module's one call per draw: the board gathers the codes of every widget of `module` that
+ * is near the screen and asks the app's `loadModule(module, codes)` once. `codes` are the parts this widget needs from
+ * that answer (default: its own code); `pick` turns them into its data (default: the one part, or every part by code
+ * when there are several).
+ */
+export interface WidgetBatch<TData = unknown> {
+    module: string;
+    codes?: readonly string[];
+    pick?: (parts: Readonly<Record<string, unknown>>) => TData;
+}
+/**
+ * A widget, declared once in the app's code: what it is, where it may go, its sizes, who may see it, where its data
+ * comes from and how it is drawn. Nothing about a widget lives in a database: only layouts do.
+ *
+ * @example
+ * const unread: WidgetDefinition<MailCounts> = {
+ *   code: "message.counts", module: "message", placement: "anywhere", title: "Mail", sizes: ["S", "M"],
+ *   batch: { module: "message" }, refresh: 60,
+ *   render: counts => <StatWidget items={[{ label: "Unread", value: counts.unread, href: "/admin/message?list=2" }]} />,
+ * };
+ */
+export interface WidgetDefinition<TData = unknown> {
+    /** Unique in the app, `module.name`: `message.counts`, `requisition.my-approvals`. What a layout keeps. */
+    code: string;
+    /** The module it belongs to: the Add list groups by it, and an `own` widget goes only on its module's board. */
+    module: string;
+    placement: WidgetPlacement;
+    /** Its heading on the board and in the Add list. */
+    title: string;
+    /** A sentence under the title in the Add list. */
+    description?: string;
+    /** Beside the title in the Add list. */
+    icon?: ReactNode;
+    /** The sizes it can take, the first the default. At least one. */
+    sizes: readonly WidgetSize[];
+    /**
+     * The permission key whose holder may see it (none: everyone signed in). The board does not read it: the app's
+     * `canSee(widget)` does, with whatever it knows of the person and the company.
+     */
+    key?: string;
+    /** Its own data call. A widget with neither `load` nor `batch` needs no data (a version, a clock). */
+    load?: (context: WidgetContext) => Promise<TData>;
+    /** Its part of its module's one call per draw, in place of `load`. */
+    batch?: WidgetBatch<TData>;
+    /** Seconds its data stays fresh while the page is open: read again after that while it is on screen. Default: the page's life. */
+    refresh?: number;
+    /** Draws it from its data. */
+    render: (data: TData, context: WidgetRenderContext) => ReactNode;
+    /** Whether the data is nothing to show: the frame then says `empty`. Default: `null`, `undefined` or an empty list. */
+    isEmpty?: (data: TData) => boolean;
+    /** What an empty widget says. Default "Nothing to show yet." */
+    empty?: ReactNode;
+    /** A link in its heading, to the page its data comes from. */
+    link?: {
+        href: string;
+        label?: string;
+    };
+}
+/** What `loadModule` answers: each asked code's part. A code left out is a part the person may not see (empty). */
+export type WidgetModuleAnswer = Readonly<Record<string, unknown>>;
+/** The app's one call per module per draw. */
+export type WidgetModuleLoader = (module: string, codes: readonly string[]) => Promise<WidgetModuleAnswer>;
+/** A widget's data as the board holds it. */
+export type WidgetState<TData = unknown> = {
+    status: "idle";
+} | {
+    status: "loading";
+    data?: TData;
+} | {
+    status: "ready";
+    data: TData;
+    at: number;
+} | {
+    status: "failed";
+    message: string;
+};

package/dist/Interfaces/DashboardInterfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/Interfaces/DomainInterfaces.d.ts

@@ -0,0 +1,145 @@
+import type { ReactNode } from "react";
+import type { ChatDomainValue, ChatId } from "./ChatInterfaces.ts";
+import type { Tone } from "./TypeInterfaces.ts";
+/** How a value is written: a plain text, a date or a moment in the reader's settings, days, money, a person's name. */
+export type DomainCardValueKind = "text" | "number" | "date" | "datetime" | "days" | "money" | "person";
+/** One field of a card: its label and value, written by its kind. A field with no value is left out. */
+export interface DomainCardField {
+    label: string;
+    /** An ISO date for `date`, a UTC moment for `datetime`, a number for `days`, `number` and `money`. */
+    value: string | number | null | undefined;
+    /** Default `text`. */
+    kind?: DomainCardValueKind;
+    /** Words after the value, quieter: "second half", "from the 2081/82 year". */
+    note?: string;
+    /** Written in place of a missing value; without it the field is left out. */
+    empty?: string;
+    /** A `money` field's currency, over the card's. */
+    currency?: string;
+}
+/** A figure: a number that matters, drawn large in a row of them ("Available 14 days", "Taken 5 days"). */
+export interface DomainCardFigure {
+    label: string;
+    /** A number is written by its kind; a text as it is. A missing value is written as "-". */
+    value: number | string | null | undefined;
+    /** Default `number`. `days` writes the unit "day" or "days" by itself. */
+    kind?: Extract<DomainCardValueKind, "number" | "days" | "money">;
+    /** Words after the value, smaller: "items". Left out for `days` (its own) and `money` (its currency). */
+    unit?: string;
+    /** Marks the figure with its colour beside it: `warning` for days held, `danger` for an overdrawn balance. */
+    tone?: Tone;
+    /** A short line under the figure: "2 of them this request". */
+    hint?: string;
+    /** A `money` figure's currency, over the card's. */
+    currency?: string;
+}
+/** A column of a card's lines. */
+export interface DomainCardLineColumn {
+    label: string;
+    /** Default `text`; `number`, `money` and `days` sit at the end. */
+    kind?: DomainCardValueKind;
+    /** Default: the end for numbers, the start for the rest. */
+    align?: "start" | "end";
+}
+/** A short table on a card: the first items of a requisition, with how many more there are. */
+export interface DomainCardLines {
+    columns: readonly DomainCardLineColumn[];
+    /** One row per line, a value per column, written by the column's kind. */
+    rows: readonly (readonly (string | number | null | undefined)[])[];
+    /** Lines the card does not show: "and 3 more". */
+    more?: number;
+    /** What the lines are, for a screen reader: "Items". Default "Lines". */
+    label?: string;
+}
+/** Where the record can be opened in full: a link at the end of the line under the title. */
+export interface DomainCardLink {
+    href: string;
+    label: string;
+    /** `_blank` opens a new tab. */
+    target?: string;
+}
+/** A card as it is drawn: what an app's `view` makes of its module's answer. */
+export interface DomainCardParams {
+    /** What the record is, in a few words: "Home leave · 2 days". */
+    title: string;
+    /** Its number, on the quiet line under the title: "LR2082-0007". */
+    code?: string | null;
+    /** Words on the line under the title, after the code: the request's own title. */
+    subtitle?: string | null;
+    /** Where it stands, as a tag in its tone: "In approval" (info), "Rejected" (danger). */
+    state?: {
+        label: string;
+        tone?: Tone;
+    } | null;
+    fields?: readonly DomainCardField[];
+    figures?: readonly DomainCardFigure[];
+    lines?: DomainCardLines | null;
+    link?: DomainCardLink | null;
+    /** The currency every `money` value is written in, unless it names its own: "Rs.". */
+    currency?: string | null;
+}
+/** What a card's `load`, `view` and `extra` are told besides the record. */
+export interface DomainCardContext {
+    /** The record's kind: the app's own domain value. */
+    domainType: ChatDomainValue;
+    /** The record's id, as the reader may open it (a token sealed for them). */
+    id: ChatId;
+    /** Who reads, when the page says (a thread's reader). */
+    viewer?: ChatId;
+    /** The record's words as the message holds them: "LR2082-0007 · Puja Shrestha". */
+    label?: string | null;
+    /** The kind's name on screen, from `defineChatDomains`: "Leave request". */
+    kind?: string;
+}
+/** How many of each part a card holds: what its placeholder draws while it loads, so it does not jump when it lands. */
+export interface DomainCardShape {
+    /** The quiet line under the title: the code, the subtitle, the link. */
+    subtitle: boolean;
+    state: boolean;
+    fields: number;
+    figures: number;
+    /** Which figures, counted from 0, have a hint under them. */
+    hints: readonly number[];
+    /** Rows of lines shown, and their columns. */
+    lines: number;
+    columns: number;
+    /** An "and 3 more" under the lines. */
+    more: boolean;
+    link: boolean;
+}
+/**
+ * The card of one kind of record: how to read it and how to show it. Give it to the kind's row of `defineChatDomains`
+ * (`card`); `domainCard(...)` types `view` by what `load` answers.
+ */
+export interface DomainCardDefinition<TData = unknown> {
+    /**
+     * Reads the record from the module that owns it: its card door, which checks the reader. A refusal of the reader
+     * (403) or a record that is not there for them (404) is shown as "You cannot open this ..."; any other failure as a
+     * failure with Try again. The signal aborts when nobody waits for the answer any more.
+     */
+    load(id: ChatId, signal: AbortSignal, context: DomainCardContext): Promise<TData>;
+    /** Maps the answer to what the card draws. */
+    view(data: TData, context: DomainCardContext): DomainCardParams;
+    /** One more piece after the lines, made of this package's parts, for a kind that needs it. */
+    extra?(data: TData, context: DomainCardContext): ReactNode;
+    /** What the placeholder holds the first time a card of this kind loads; later ones hold the last card's shape. */
+    held?: Partial<DomainCardShape>;
+    /** How long an answer is kept for every card of the page, in milliseconds. Default 30,000; 0 keeps none. */
+    lifetime?: number;
+}
+/** Where one card stands. */
+export type DomainCardStatus = "loading" | "ready" | "refused" | "failed";
+/** One card's read, as its component draws it. */
+export interface DomainCardSnapshot<TData = unknown> {
+    status: DomainCardStatus;
+    /** The record as last read: kept on screen while it is read again, and when reading again fails. */
+    data?: TData;
+    /** A read is on its way while the card shows what it read before. */
+    refreshing: boolean;
+    /** The last read again failed: the card on screen is the one read before. */
+    refreshFailed: boolean;
+    /** When a read again found the record changed from the one on screen (milliseconds since 1970). */
+    changedAt?: number;
+    /** Why the last read failed. */
+    error?: unknown;
+}

package/dist/Interfaces/DomainInterfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/Interfaces/FileInterfaces.d.ts

@@ -16,6 +16,14 @@ export interface FileOwner<TModule extends ApiModuleValue = AppModule> {
 }
 /** Which copy of a stored file: the file itself, or its small picture. */
 export type FileCopy = "original" | "thumbnail";
+/**
+ * One way an owner's files change: a file added, renamed, made the owner's picture (or none), or deleted. In words, as a
+ * category's kinds are MIME types; they are the Nexus core's `EFileChanges` (Add 1, Rename 2, Primary 3, Remove 4) one
+ * for one. A record whose files may only be added to - a posted goods receipt's documents - allows `["add"]`.
+ */
+export type FileChange = "add" | "rename" | "primary" | "remove";
+/** Every change, in the order the core numbers them. */
+export declare const FILE_CHANGES: readonly FileChange[];
 /** One stored file, as the adapter reads it. */
 export interface StoredFile {
     /** Its id, as the backend answers it (with Nexus, encrypted for the person asking). */
@@ -35,6 +43,14 @@ export interface StoredFile {
     isPrimary: boolean;
     /** When it was stored: an ISO UTC moment, or null when the backend does not say. */
     createdAt: string | null;
+    /**
+     * Its Delete waits for a review: in a category that holds removals (`FileCategoryInfo.holdsRemovals`, a reviewed
+     * gallery) a Delete only marks the file, which is still served and listed until the reviewer decides, and the person
+     * may Keep it (`FileAdapter.keep`) until then. Left out (or false) for every other file.
+     */
+    pendingRemoval?: boolean;
+    /** When its removal was asked, while it waits for the review: an ISO UTC moment, when the backend says. */
+    removalAt?: string;
 }
 /** What a category takes, as the backend says: what a gallery tells the person before an upload is refused. */
 export interface FileCategoryInfo {
@@ -64,6 +80,11 @@ export interface FileCategoryInfo {
      * picture under it (a lower quality, then a smaller size). Default `PICTURE_LIMITS.maxBytes` (300 KB), at most `maxBytes`.
      */
     pictureMaxBytes?: number;
+    /**
+     * A Delete here waits for a review (a company's public gallery, which Nexus support approves): the file is marked
+     * `pendingRemoval`, not removed, until the reviewer decides. Left out (or false) where a Delete removes at once.
+     */
+    holdsRemovals?: boolean;
 }
 /** An owner's files and what their category takes. */
 export interface OwnerFiles {

package/dist/Interfaces/FileInterfaces.js

@@ -1,3 +1,5 @@
+/** Every change, in the order the core numbers them. */
+export const FILE_CHANGES = ["add", "rename", "primary", "remove"];
 /** The MIME types of pictures (what a canvas can read back), in the order a file picker offers them. */
 export const PICTURE_TYPES = ["image/jpeg", "image/png", "image/webp"];
 /** Whether a MIME type is a picture this package can show and edit. */

package/dist/Interfaces/FormInterfaces.d.ts

@@ -124,20 +124,29 @@ export interface InputLayoutParams {
      */
     dependsOn?: readonly string[];
     /**
-     * Another input of the same form whose value narrows this one's options (Form only): a Package list of the Group picked.
+     * Another input of the same form whose value narrows this one's options (Form, and the rows of its tabular and group
+     * forms): a Package list of the Group picked.
      * The options are the records whose `key` field holds that value (static `options` filtered; `loadOptions` asked with
      * `request.narrow`, which `crudPicker` answers from the server when its endpoint takes the parent, else from its kept list);
      * the list loads afresh when the value changes, offers nothing while it is empty, and says what to pick first. A value
      * picked here is cleared when a person changes the other one. It follows the other input as `dependsOn` would.
      *
+     * Several narrow at once (a list): the options must fit every one, the box says what to pick first for the first one
+     * still empty, and the list loads afresh when any changes. In a row of a tabular or group form a narrowing names an
+     * input of the same row, or of the form around the rows with `from: "form"`: an asset line's Tags, the units of the
+     * line's Item in the form's Store. A value picked is cleared when a person changes one it follows (every row's, for
+     * the form's), never when code sets it (a draft loading).
+     *
      * @example { type: EInputTypes.Dropdown, name: "subscriptionPackageId", label: "Package", ...crudPicker(PACKAGES, { labelKey: "packageName" }), narrowedBy: { name: "subscriptionGroupId" } }
+     * @example narrowedBy: [{ name: "storeId", from: "form" }, { name: "itemId" }] // a line's Tags: the form's Store, the row's Item
      */
-    narrowedBy?: InputNarrowing;
+    narrowedBy?: InputNarrowing | readonly InputNarrowing[];
     /**
      * When the input shows (Form only): while every condition holds, each on another input's value as it is now. The form
      * follows the inputs named as `dependsOn` would, so the input comes and goes as they change, keeps what was typed in it
      * (its value stays in the data, as a `hidden` one's does) and is not checked while it is hidden. A `hidden: true`, or a
-     * `hidden` getter, still hides it whatever the conditions say.
+     * `hidden` getter, still hides it whatever the conditions say. A CRUD's Add or Edit saved while it is hidden leaves it
+     * on the row only as the server holds it: as the answer gives it, else as what was sent gives it (`crudSavedRecord`).
      *
      * @example showWhen: { name: "counterType", in: [0, 1] }
      * @example showWhen: [{ name: "counterType", in: [2] }, { name: "subscriptionMiscellaneousFeeId", filled: false }]
@@ -198,12 +207,14 @@ export interface InputLayoutParams {
      */
     spanWhen?: InputSpanWhen;
     /**
-     * A value worked out from other inputs (Form only), shown and never typed: written when the form opens (new values, a
-     * loaded record) and again whenever an input in `from` changes - by a person, by code, a load, a reset - or the form's
-     * `computeWith` changes. It is no form value: never sent, never checked, never a change, never remembered or kept in a
-     * draft. Meant for a Number (its `decimals`, `prefix`, `suffix`, in the person's number format); any other type shows
-     * its text. Null, undefined, "" or NaN leave the box blank. The box is an `<output>` on the read-only tint, with no
-     * lock, no steppers and no Tab stop. In a tabular or group form's rows it is ignored, as `showWhen` is.
+     * A value worked out from other inputs, shown and never typed (unless `solve` makes it so): written when the form opens
+     * (new values, a loaded record) and again whenever an input in `from` changes - by a person, by code, a load, a reset -
+     * or the form's `computeWith` changes. It is no form value: never sent, never checked, never a change, never remembered
+     * or kept in a draft. Meant for a Number (its `decimals`, `prefix`, `suffix`, in the person's number format); any other
+     * type shows its text. Null, undefined, "" or NaN leave the box blank. The box is an `<output>` on the read-only tint,
+     * with no lock, no steppers and no Tab stop. In a tabular or group form's rows it works on each row alike: `from` names
+     * the row's inputs, `values` is the row, `withValue` the rows' `computeWith`, and the rows hold no value under its name
+     * (a loaded row's field of that name is dropped).
      *
      * @example compute: { from: ["price", "discountPercentage", "vatPercentage"], value: values => priceAmounts(values).netAmount }
      * @example compute: { from: [], value: (_values, preview) => preview?.netAmount }   // with computeWith={preview}
@@ -220,6 +231,28 @@ export interface InputCompute<TWith = any> {
     from: readonly string[];
     /** The value to show. `withValue` is the form's `computeWith`, as the page passed it (`undefined` when it passed none). */
     value(values: FormValues, withValue: TWith): unknown;
+    /**
+     * Works it backwards, which makes the box editable (a Number input): a person types the figure they want and leaves the
+     * box (Tab, a click away, or Enter), and this answers the values of the inputs it is worked out from that give it - the
+     * inverse of `value`. The form writes them as the person's own change (their rules, the form's `onFieldChange`, the
+     * unsaved-changes state, Save and the leave guard see those inputs; the worked-out input still holds no value), then
+     * shows the figure worked forward again, with a line under the box: what was set ("Price set to 2,458.21"), and, when
+     * the figure typed cannot be reached exactly, the nearest it now shows. Answer a sentence to refuse (the box goes back,
+     * the sentence shows under it), or `null` to change nothing. Escape puts back what the box showed; an emptied box changes
+     * nothing. The box is read-only, as without `solve`, while the form is read-only, disabled or loading. In a row it
+     * works the same on that row (the rows' `onRowChange` runs for what it sets); a table says the line under the rows,
+     * since its cells have none, and Enter with a new figure sets it rather than moving down the column.
+     *
+     * @example solve: (typed, values) => { const found = priceFromNet(typed, values); return found.ok ? { values: { price: found.price } } : found.message; }
+     */
+    solve?(typed: number, values: FormValues, withValue: TWith): InputSolved | string | null;
+}
+/** What an input worked backwards answers (`InputCompute.solve`): the values of the inputs it is worked out from. */
+export interface InputSolved {
+    /** The inputs' new values, by name: `{ price: 2458.21 }`. */
+    values: FormValues;
+    /** The line under the box, in place of the form's own ("Price set to 2,458.21."). */
+    note?: string;
 }
 /** An input's label that follows another input's value (`InputLayoutParams.labelWhen`). */
 export interface InputLabelWhen {
@@ -300,6 +333,11 @@ export interface InputNarrowingByInput {
     placeholder?: string;
     /** Also offers the options whose `key` field is empty: a fee of every group beside the group's own. */
     orUnset?: boolean;
+    /**
+     * For an input in a row of a tabular or group form, where `name` is: `"row"` (default) an input of the same row - the
+     * line's Item - or `"form"` an input of the form around the rows - the document's Store. Outside rows, ignored.
+     */
+    from?: "row" | "form";
     value?: never;
 }
 /**
@@ -385,6 +423,11 @@ export interface InputValidationContext {
 /** One row of a tabular or group form: the values by input name, plus any other fields the row came with, such as its id. */
 export type RowValue = Record<string, unknown>;
 /** Props shared by `TabularForm` and `GroupForm`. The value is an array of rows; each row holds one value per input. */
+/** A value of the form around rows that a row input is narrowed by (`RowsInputProps.formValues`), and its label. */
+export interface RowsFormValue {
+    value: unknown;
+    label?: ReactNode;
+}
 export interface RowsInputProps<TRow extends RowValue = RowValue> {
     /** The inputs of one row, as params. Keep the array stable (a constant or `useMemo`): a new one checks every row again. */
     inputs: readonly InputParams[];
@@ -474,6 +517,18 @@ export interface RowsInputProps<TRow extends RowValue = RowValue> {
      * 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;
+    /**
+     * The values of the form around the rows that a row input's `narrowedBy` names `from: "form"` (the document's Store),
+     * each with its label for "Pick a store first". A `Form` sets them as they change, and the rows draw again then; a rows
+     * input used on its own takes them from the page.
+     */
+    formValues?: Readonly<Record<string, RowsFormValue>>;
+    /**
+     * What a row input worked out from others (`compute`) is handed as `withValue`, beside the row's values: a rate the
+     * whole document shares, the company's VAT. Every row's worked-out cells draw again when a new one comes (compared by
+     * identity: pass state or `useMemo`). A `Form` hands the rows its own `computeWith` unless their params name one.
+     */
+    computeWith?: unknown;
     /** 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." */
@@ -759,6 +814,15 @@ export interface ApiRequest {
 }
 /** Sends a form's values with the app's own client. Return what it answers: a `Response`, a parsed body, or an `ApiResult`. */
 export type ApiSend<TValues extends FormValues = FormValues> = (body: unknown, context: FormSubmitContext<TValues>) => Promise<unknown>;
+/**
+ * What an `ApiForm`'s save sent (`onSuccess`): the form's values as they were sent - values typed while it ran are not
+ * among them - and the body `transform` made of them (the values themselves without one). A row built from the save
+ * reads the body: a field `transform` cleared is cleared there, where the values still hold what was typed.
+ */
+export interface ApiFormSent<TValues extends FormValues = FormValues> {
+    values: TValues;
+    body: unknown;
+}
 /** Props of `ApiForm`: a `SubmitForm` that sends the values to an API and shows the server's messages on their inputs. */
 export interface ApiFormProps<TValues extends FormValues = FormValues> extends Omit<SubmitFormProps<TValues>, "onSubmit" | "onSaved"> {
     /**
@@ -779,8 +843,11 @@ export interface ApiFormProps<TValues extends FormValues = FormValues> extends O
      * 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. */
-    onSuccess?: (result: unknown, values: TValues, form: FormStore<TValues>) => void;
+    /**
+     * 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. `sent` is what that save sent: the values as they were then, and the body `transform` made of them.
+     */
+    onSuccess?: (result: unknown, values: TValues, form: FormStore<TValues>, sent: ApiFormSent<TValues>) => void;
     /** After a failed save, with the server's answer. The form already shows its messages. */
     onError?: (response: ApiResult, values: TValues) => void;
     /** The toast after a save: text, or `false` for none. Default: the server's message, else the endpoint's ("Room saved."), else "Saved." */

package/dist/Interfaces/InputInterfaces.d.ts

@@ -161,11 +161,18 @@ export interface DropdownPageRequest {
      * of its own should honour it (`crudPicker` does); a static list is narrowed by the form itself. `orUnset`: the options
      * whose `key` field is empty are offered too (`narrowedBy.orUnset`), and a `null` value then offers only those.
      */
-    narrow?: {
-        key: string;
-        value: OptionValue | null;
-        orUnset?: boolean;
-    };
+    narrow?: DropdownNarrow;
+    /**
+     * Every narrowing, when several narrow at once (`narrowedBy` as a list: the form's Store and the row's Item): the
+     * options must fit each. `narrow` is the first of them, for a source that reads one. Absent with one narrowing or none.
+     */
+    narrows?: readonly DropdownNarrow[];
+}
+/** One narrowing of a picker's options: the records whose `key` field holds `value` (`orUnset`: or is empty). */
+export interface DropdownNarrow {
+    key: string;
+    value: OptionValue | null;
+    orUnset?: boolean;
 }
 /** What `loadOptions` returns for one page. */
 export interface DropdownPage<TItem extends DropdownItem = DropdownItem> {