nexus-shared 3.1.0 → 4.0.0

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. */
@@ -103,8 +127,10 @@ export type DropdownItem = object;
  * - `avatar`: a round photo from a URL; the initials of the item's label when there is no URL or it fails to load.
  * - `image`: a small picture from a URL, 4:3, such as a flag or a logo.
  * - `icon`: a Tabler icon by name, such as `"wifi"`.
+ * - `money`: a figure with 2 places in the person's number format (1,00,000.00 under lakh and crore), at the end of the
+ *   column in even digits, such as a fee's price beside its name; empty for a missing one.
  */
-export type DropdownColumnType = "text" | "muted" | "code" | "avatar" | "image" | "icon";
+export type DropdownColumnType = "text" | "muted" | "code" | "avatar" | "image" | "icon" | "money";
 /** One column of a dropdown's rows. Plain values, so a list of fields can describe it; `render` is the only function. */
 export interface DropdownColumn<TItem extends DropdownItem = DropdownItem> {
     /** The item's field, e.g. `"username"`. */
@@ -113,9 +139,9 @@ export interface DropdownColumn<TItem extends DropdownItem = DropdownItem> {
     header?: string;
     /** Default `text`. */
     type?: DropdownColumnType;
-    /** A CSS grid track: `"6rem"`, `"auto"`, `"1fr"`. Default: `auto` for avatar, image, icon, and code; `minmax(0, 1fr)` for text. */
+    /** A CSS grid track: `"6rem"`, `"auto"`, `"1fr"`. Default: `auto` for avatar, image, icon, code, and money; `minmax(0, 1fr)` for text. */
     width?: string;
-    /** Default `start`. */
+    /** Default `start`; `end` for `money`. */
     align?: "start" | "center" | "end";
     /** Draws the cell instead of `type`. */
     render?: (item: TItem) => ReactNode;
@@ -130,6 +156,16 @@ export interface DropdownPageRequest {
     skip: number;
     /** Aborted when a newer search replaces this request, or the dropdown unmounts. */
     signal: AbortSignal;
+    /**
+     * Only the options whose `key` field holds `value`: set by a form for an input another narrows (`narrowedBy`). A source
+     * 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;
+    };
 }
 /** What `loadOptions` returns for one page. */
 export interface DropdownPage<TItem extends DropdownItem = DropdownItem> {

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/RecordInterfaces.d.ts

@@ -0,0 +1,367 @@
+import type { ReactNode } from "react";
+import type { PopupSize } from "../Components/Layouts/Popup.tsx";
+import type { ApiEndpoint, ApiResult, ApiTarget } from "./ApiInterfaces.ts";
+import type { CrudDetailsPicture } from "./CrudInterfaces.ts";
+import type { FormStore } from "../Helpers/FormStore.ts";
+import type { ApiRequest, ApiSend, FormRuleResult, FormSubmitTone, FormValues, InputParams } from "./FormInterfaces.ts";
+import type { Tone } from "./TypeInterfaces.ts";
+/**
+ * How a part of the page is read: an endpoint or a URL, read with GET through the app's `api`, or a function of the
+ * page's own answering an `ApiResult` (the API client's shape: it never throws).
+ */
+export type RecordRead<T = any> = ApiTarget | ((signal: AbortSignal) => Promise<ApiResult<T>>);
+/** A source given with what is known before it is read: the name the session already has, drawn while it loads. */
+export interface RecordSourceParams<T = any> {
+    read: RecordRead<T>;
+    /** Drawn while the read runs (the hero's name from the session), so nothing moves when it lands. */
+    held?: Partial<T>;
+}
+/**
+ * What an answer writes into the card's data, which every card on the same source then shows:
+ * - `"answer"`: a record answer, merged over the data as held now (only the fields it carries); a list answer replaces a
+ *   list. Default. An answer that is neither falls back to the values (a card's Edit) or a read again (the rest).
+ * - `"values"`: the values sent, merged over the data as held now.
+ * - `"item"`: the answer is one item: it replaces the item of the same key, or is added at the end.
+ * - `"remove"`: the item acted on leaves the list.
+ * - `"reload"`: the source is read again. `"none"`: nothing.
+ * - field names: those the answer carries, over the data as held now.
+ * - a function: what to merge over the data as held now (a record), or the data's new value; `null` writes nothing.
+ */
+export type RecordWrites<TData = any, TValues = any> = "answer" | "values" | "item" | "remove" | "reload" | "none" | readonly string[] | ((result: unknown, data: TData, values: TValues) => TData | Partial<TData> | null | undefined);
+/** A short mark beside a name: "Primary", "Not verified", "This device". */
+export interface RecordMark {
+    label: ReactNode;
+    tone?: Tone;
+}
+/**
+ * Where a step's values go: an endpoint, a URL (sent as a POST of JSON), a request to a URL outside the app's modules
+ * (`{ url, method }`), or a function of the page's own.
+ */
+export type RecordSubmit<TValues extends FormValues = any> = string | ApiRequest | ApiEndpoint | ApiSend<TValues>;
+/** What every step, confirm and action is handed: the card's data and the item as held now, and the ways on. */
+export interface RecordContext<TData = any, TItem = any> {
+    /** The card's data as the page holds it now. */
+    data: TData;
+    /** The item acted on, as held now (found again by its key after each write); `undefined` for a card's own action. */
+    item: TItem | undefined;
+    /** The page or the card is read-only. */
+    readOnly: boolean;
+    /** Reads the card's source again: its data, or `null` when it could not be read (said in a toast, the data kept). */
+    reload: () => Promise<TData | null>;
+    /** Writes the card's source: every card on it shows the new data. */
+    write: (next: TData) => void;
+    /** Runs one of the card's item actions on an item: Make primary after a Verify left no primary, the code step after an Add. */
+    run: (action: string, item: [TItem] extends [undefined] ? any : TItem) => void;
+    /** Opens a popup for this card (and this item): a content card's own button, a two-step setup. */
+    open: (flow: RecordFlowParams<TData, TItem>) => void;
+}
+/** How a step is shown by `goTo`. */
+export interface RecordGoToOptions {
+    /** Shown afresh: what was typed in it before (a password, an old code) is dropped, and it opens on its values again. */
+    fresh?: boolean;
+}
+/** What a popup's step is handed: the context, which step it is, its form, and the answer of the step that led to it. */
+export interface RecordStepContext<TData = any, TItem = any> extends RecordContext<TData, TItem> {
+    step: string;
+    /** The answer of the step before, the one that led here. */
+    result: unknown;
+    /**
+     * The step's form: its values as typed now (`form.get("countryId")`), for inputs whose label, `hidden` or options follow
+     * another input through getters (give them `dependsOn`). Each step has its own; one shown fresh gets a new one.
+     */
+    form: FormStore;
+    /** Shows another step of the popup; `{ fresh: true }` shows it as if for the first time. */
+    goTo: (step: string, options?: RecordGoToOptions) => void;
+    /** Closes the popup. */
+    close: () => void;
+}
+/** What a step's `next` and `done` are handed after its save: the context, the answer, and the values sent. */
+export interface RecordStepAnswer<TData = any, TItem = any, TValues = any> extends RecordStepContext<TData, TItem> {
+    result: unknown;
+    values: TValues;
+}
+/** A button in a step that calls an endpoint and stays on the step: "Send a new code", held while the server says. */
+export interface RecordCallParams<TData = any, TItem = any> {
+    label: ReactNode | ((context: RecordStepContext<TData, TItem>) => ReactNode);
+    icon?: ReactNode;
+    submit: ApiTarget | ApiRequest | ((body: unknown) => Promise<unknown>);
+    /** What is sent. Default: nothing. */
+    transform?: (context: RecordStepContext<TData, TItem>) => unknown;
+    /** What its answer writes (default `"answer"`, else nothing). */
+    writes?: RecordWrites<TData>;
+    /** Held until this moment (an ISO text or a time in ms), counted down in its label: the server's resend time. */
+    waitUntil?: (context: RecordStepContext<TData, TItem>) => string | number | null | undefined;
+    /** The label while it waits. Default "Again in 23s". */
+    waitLabel?: (seconds: number) => ReactNode;
+    /** The toast after it answered. Default the server's message; `false` for none. */
+    successMessage?: ReactNode | false;
+    /** The input given the cursor after it answered: the code's boxes. */
+    focus?: string;
+}
+/** One step of a popup: a sentence, its inputs, where they go, what the answer writes, and what follows. */
+export interface RecordStepParams<TData = any, TItem = any, TValues extends FormValues = any> {
+    /** Names the step for `next` and `start`. Default its place: "1", "2". */
+    id?: string;
+    /** The popup's title on this step. Default the flow's. */
+    title?: ReactNode | ((context: RecordStepContext<TData, TItem>) => ReactNode);
+    /** The line under the title. Default the flow's. */
+    description?: ReactNode | ((context: RecordStepContext<TData, TItem>) => ReactNode);
+    /** A sentence over the inputs: what will happen, where a code went. It follows the data as held now. */
+    lead?: ReactNode | ((context: RecordStepContext<TData, TItem>) => ReactNode);
+    /**
+     * The inputs. None: the step is its sentence and its button ("Send a code"). A function is handed the step's `form`,
+     * so an input's label or `hidden` can follow another input as typed (a region level named after the place above it).
+     */
+    inputs?: readonly InputParams[] | ((context: RecordStepContext<TData, TItem>) => readonly InputParams[]);
+    /** What the form opens on. Default: the item for an item's step, the card's data for a card's Edit, nothing for an Add. */
+    values?: (context: RecordStepContext<TData, TItem>) => Partial<TValues>;
+    /** Where the values go. */
+    submit?: RecordSubmit<TValues>;
+    /**
+     * The step's own rule over all its values, asked before anything is sent, as a form's `validate`: messages by input
+     * name, or one text for the whole step (a new password and its confirmation that differ).
+     */
+    validate?: (values: TValues, context: RecordStepContext<TData, TItem>) => FormRuleResult;
+    /**
+     * Shown afresh each time it is reached again (by `next` or `goTo`): a step of a password or a code, whose old values
+     * are no use. Default false: a step shown again keeps what was typed in it.
+     */
+    fresh?: boolean;
+    /**
+     * What is sent. Default: the values merged over what the step opened on, as held now - the whole record for a card's
+     * Edit (so an endpoint that takes the whole record works), the item for an item's step; the values alone for an Add.
+     */
+    transform?: (values: TValues, context: RecordStepContext<TData, TItem>) => unknown;
+    /** Default "Save". */
+    submitLabel?: ReactNode;
+    /** Default a floppy disk; `null` for none. */
+    submitIcon?: ReactNode | null;
+    /** `danger` for a step whose save removes something. */
+    submitTone?: FormSubmitTone;
+    /** What the answer writes into the card's data. Default `"answer"`. */
+    writes?: RecordWrites<TData, TValues>;
+    /** The step after this one, by its id; nothing closes the popup. */
+    next?: string | ((answer: RecordStepAnswer<TData, TItem, TValues>) => string | null | undefined);
+    /** After the last step's save, once the popup has closed: open what follows (`run`). */
+    done?: (answer: RecordStepAnswer<TData, TItem, TValues>) => void;
+    /** A button under the form that calls an endpoint and stays on the step. */
+    also?: RecordCallParams<TData, TItem>;
+    /** The toast after the save. Default the server's message; `false` for none. */
+    successMessage?: ReactNode | false | ((answer: RecordStepAnswer<TData, TItem, TValues>) => ReactNode | false);
+    /** Told of a refusal, which the form already shows on its inputs: a code that offers another way. */
+    onError?: (answer: ApiResult, context: RecordStepContext<TData, TItem>) => void;
+    /**
+     * Cancel, the close button and leaving the page ask before dropping changes. Default true. A password or a code typed
+     * is never asked about (it is no change worth keeping); false for a step whose other values are not worth it either.
+     */
+    confirmCancel?: boolean;
+    /** The page's own part under the form: a "Set a password" link after a refusal. */
+    render?: (context: RecordStepContext<TData, TItem>) => ReactNode;
+}
+/**
+ * A popup: one step (the flow is that step) or several (`steps`), opened by a card's Edit or Add, or by an item's
+ * action. One popup per card, action and item: opened again, it comes back as it was.
+ */
+export interface RecordFlowParams<TData = any, TItem = any, TValues extends FormValues = any> extends RecordStepParams<TData, TItem, TValues> {
+    /** The button that opens it: "Edit", "Add". */
+    label?: string;
+    /** The button's icon and the popup's. */
+    icon?: ReactNode;
+    /** Default `md` for a card's Edit with more than two inputs, else `sm`. */
+    size?: PopupSize;
+    /** Several steps, in order: the first unless `start` says. */
+    steps?: readonly RecordStepParams<TData, TItem>[];
+    /** The step it opens on: "code" when a code already waits. */
+    start?: string | ((context: RecordContext<TData, TItem>) => string);
+}
+/** A question before a change that needs no form: "Remove ram@example.com?", then the call. */
+export interface RecordConfirmParams<TData = any, TItem = any> {
+    title: ReactNode | ((context: RecordContext<TData, TItem>) => ReactNode);
+    message?: ReactNode | ((context: RecordContext<TData, TItem>) => ReactNode);
+    /** Default "Remove" for a danger tone, else "OK". */
+    confirmLabel?: ReactNode;
+    /** Default `danger`. */
+    tone?: "danger" | "warning" | "question" | "info";
+    submit: ApiTarget | ApiRequest | ((body: unknown) => Promise<unknown>);
+    /** What is sent. Default: the item, or the card's data. */
+    transform?: (context: RecordContext<TData, TItem>) => unknown;
+    /** What the answer writes. Default `"answer"`, else a read again. */
+    writes?: RecordWrites<TData>;
+    /** The toast after it. Default the server's message, else "Done". `false` for none. */
+    successMessage?: ReactNode | false | ((context: RecordContext<TData, TItem>) => ReactNode | false);
+    /** After the call answered and the card was written. */
+    done?: (context: RecordContext<TData, TItem> & {
+        result: unknown;
+    }) => void;
+}
+/** A button in a card's heading: a popup (`flow`), a question then a call (`confirm`), or the page's own (`onSelect`). */
+export interface RecordCardActionParams<TData = any> {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    tone?: "danger";
+    /** Not shown for this data. Asked only once the data is read (see `loading`). */
+    hidden?: (data: TData) => boolean;
+    /**
+     * Shown switched off with this reason, said when pressed: "You have 5 emails, the most there may be." Asked only once
+     * the data is read.
+     */
+    held?: (data: TData) => string | false | null | undefined;
+    /**
+     * How it shows while the data is read, before `hidden` and `held` can be asked: `held` (default) switched off, saying
+     * "Still being read."; `hidden` not yet drawn - for an action seldom shown (Turn off on a setting mostly off).
+     */
+    loading?: "held" | "hidden";
+    flow?: RecordFlowParams<TData, undefined>;
+    confirm?: RecordConfirmParams<TData, undefined>;
+    onSelect?: (context: RecordContext<TData, undefined>) => void;
+}
+/** An icon button on the right of an item: named as a tooltip and to a screen reader, hidden or held with its reason. */
+export interface RecordItemActionParams<TData = any, TItem = any> {
+    id: string;
+    /** Its name, the tooltip and what a screen reader says (with the item's name): "Verify", "Make primary". */
+    label: string | ((item: TItem, data: TData) => string);
+    icon: ReactNode;
+    tone?: "danger";
+    /** Not shown on this item. */
+    hidden?: (item: TItem, data: TData) => boolean;
+    /** Shown switched off with this reason, said when pressed: "The primary email cannot be removed." */
+    held?: (item: TItem, data: TData) => string | false | null | undefined;
+    flow?: RecordFlowParams<TData, TItem>;
+    confirm?: RecordConfirmParams<TData, TItem>;
+    onSelect?: (context: RecordContext<TData, TItem>) => void;
+}
+/** What one card has whatever it holds. */
+export interface RecordCardBase<TData = any> {
+    /** The card's element id, so a link can lead to it (`/dashboard/profile#emails`); unique on the page. */
+    id: string;
+    /** The source it is drawn from (a key of `sources`). Default the first. */
+    source?: string;
+    title: ReactNode;
+    icon?: ReactNode;
+    /** A sentence under the title. */
+    description?: ReactNode | ((data: TData) => ReactNode);
+    /** Buttons in the heading, after the card's own Edit or Add. */
+    actions?: readonly RecordCardActionParams<TData>[];
+    /** Not shown for this data (judged once it is read). */
+    hidden?: (data: TData) => boolean;
+    /** Takes the page's whole width. */
+    wide?: boolean;
+    /** No buttons and no actions in this card. */
+    readOnly?: boolean;
+}
+/** One value of a fields card, when its input alone does not say how to show it. */
+export interface RecordFieldParams<TData = any> {
+    /** The input the value is drawn by (a choice by its label, a date in the person's format) and edited with. */
+    input: InputParams;
+    /** Default the input's label. */
+    label?: ReactNode;
+    /** `chips` for a list written with commas (keywords), `lines` for text on its own lines. Default by the input's type. */
+    look?: "text" | "lines" | "chips";
+    /** The value drawn by the page. */
+    show?: (value: unknown, data: TData) => ReactNode;
+    /** In the Edit popup. Default true; false for a value only shown here (the primary email). */
+    edit?: boolean;
+    hidden?: (data: TData) => boolean;
+    /** Takes the card's whole width. Default for long text and chips. */
+    wide?: boolean;
+    /**
+     * Lines the value holds while it is read, so the card is as tall as it will be: about what the value usually takes.
+     * Default 2 for long text, else 1.
+     */
+    heldLines?: number;
+}
+/** A card of labels and values, drawn from the inputs its Edit popup uses. */
+export interface RecordFieldsCardParams<TData = any> extends RecordCardBase<TData> {
+    fields: readonly (InputParams | RecordFieldParams<TData>)[];
+    /**
+     * The heading's Edit: a popup of the card's inputs (those with `edit` not false) on the data as loaded, whose values are
+     * merged over the record as held now, so an endpoint that takes the whole record works. Needs `submit`.
+     */
+    edit?: RecordFlowParams<TData, undefined>;
+    /** What an empty value says. Default "Not said". */
+    empty?: ReactNode;
+}
+/** How one item reads: a picture or an icon, its name, lines under it, and marks. */
+export interface RecordItemView {
+    title: ReactNode;
+    lines?: readonly ReactNode[];
+    marks?: readonly RecordMark[];
+    /** A picture at the start (an `Avatar`, an `OwnerPicture`). */
+    picture?: ReactNode;
+    /** An icon at the start, where there is no picture. */
+    icon?: ReactNode;
+}
+/** A card of items: a list with Add in its heading and icon actions on each item's right. */
+export interface RecordItemsCardParams<TData = any, TItem = any> extends RecordCardBase<TData> {
+    /** Where the items are: a field of the data (`"items"`), or a function. Default: the data is the list. */
+    items?: string | ((data: TData) => readonly TItem[]);
+    /** What tells one item from another: a field, or a function. */
+    itemKey: string | ((item: TItem) => string | number);
+    item: (item: TItem, data: TData) => RecordItemView;
+    /** The item's name for a screen reader ("Verify: ram@example.com"). Default its title when it is text. */
+    itemLabel?: (item: TItem) => string;
+    itemActions?: readonly RecordItemActionParams<TData, TItem>[];
+    /** The heading's Add: a popup form; held at the `limit`, saying why. Needs `submit`. */
+    add?: RecordFlowParams<TData, undefined>;
+    /** The most there may be: shown as "3 of 5", and Add held there. A field of the data, a number or a function. */
+    limit?: number | string | ((data: TData) => number | null | undefined);
+    /** Why Add is held at the limit. Default "The most there may be is 5. Remove one first." */
+    limitReason?: string | ((limit: number) => string);
+    /** What an empty list says. Default "Nothing here yet." */
+    empty?: ReactNode;
+    /** Rows drawn while the list loads: as many as it usually has, so nothing under the card moves. Default 2. */
+    heldRows?: number;
+    /** Lines under each held row's name: as many as a row usually has (`item(...).lines`). Default 1. */
+    heldRowLines?: number;
+}
+/** A card of the page's own. */
+export interface RecordContentCardParams<TData = any> extends RecordCardBase<TData> {
+    render: (context: RecordContext<TData, undefined>) => ReactNode;
+}
+export type RecordCardParams<TData = any, TItem = any> = RecordFieldsCardParams<TData> | RecordItemsCardParams<TData, TItem> | RecordContentCardParams<TData>;
+/** The card across the top: the picture (a click opens the pictures window), the name, a line or two, and marks. */
+export interface RecordHeroParams<TData = any> {
+    /** Default the first source. */
+    source?: string;
+    /** The owner's main picture by its Drive params (`CrudDetailsPicture`), or anything to draw in its place. */
+    picture?: (data: TData) => CrudDetailsPicture | ReactNode;
+    title: (data: TData) => ReactNode;
+    /** Lines under the name. While the source loads they are given what `held` says; an empty one keeps its line. */
+    lines?: (data: TData) => readonly ReactNode[];
+    marks?: (data: TData) => readonly RecordMark[];
+    actions?: readonly RecordCardActionParams<TData>[];
+}
+/** What the page shows when a read or a change finds the session ended: its own words, and the way back in. */
+export interface RecordSignedOutParams {
+    /** Default "Your session has ended". */
+    title?: ReactNode;
+    /** Default the answer's message. */
+    message?: ReactNode | ((answer: ApiResult) => ReactNode);
+    /** Default "Sign in again". */
+    label?: ReactNode;
+    onSignIn: () => void;
+    /** Told once, when the session is found ended. */
+    onEnded?: (answer: ApiResult) => void;
+}
+export interface RecordCardsProps {
+    /**
+     * What the page reads, by name, each once when it is first drawn (a new `key` reads them afresh):
+     * `{ profile: { read: ACCOUNT_API.profile, held: { fullName } }, emails: ACCOUNT_API.emails }`.
+     */
+    sources: Readonly<Record<string, RecordRead | RecordSourceParams>>;
+    hero?: RecordHeroParams;
+    cards: readonly RecordCardParams[];
+    /** No buttons and no actions anywhere: a person who may only look. */
+    readOnly?: boolean;
+    /** Without it, an ended session is a failed read like any other. */
+    signedOut?: RecordSignedOutParams;
+    /** Which answers mean the session ended. Default: a 401 that names no input (a wrong password names its box). */
+    isSessionEnded?: (answer: ApiResult) => boolean;
+    /** Tells this page's popups from another's. Default "record". */
+    name?: string;
+    /** The level of the cards' headings. Default 2, under the page's own. */
+    headingLevel?: 2 | 3;
+    "aria-label"?: string;
+    className?: string;
+}

package/dist/Interfaces/RecordInterfaces.js

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