nexus-shared 3.2.0 → 4.0.0

package/dist/Helpers/ExcelHelpers.js

@@ -1,3 +1,4 @@
+import { EInputTypes } from "../Interfaces/FormInterfaces.js";
 import { ExcelDataType, ExcelRowKind } from "../Interfaces/ExcelInterfaces.js";
 import { toIsoDate } from "./DateHelpers.js";
 import { toIsoTime } from "./TimeHelpers.js";
@@ -111,28 +112,28 @@ export function excelColumnInput(column) {
         ...(column.maximum === null || column.maximum === undefined ? {} : { max: column.maximum }),
     };
     if (column.isReference)
-        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("referenceLocked") };
+        return { ...shared, type: EInputTypes.Text, readOnly: true, readOnlyMessage: excelText("referenceLocked") };
     if (column.isReadOnly)
-        return { ...shared, type: "text", readOnly: true, readOnlyMessage: excelText("generated") };
+        return { ...shared, type: EInputTypes.Text, readOnly: true, readOnlyMessage: excelText("generated") };
     switch (column.dataType) {
         case ExcelDataType.Note:
-            return { ...shared, type: "textarea", rows: 2, required, ...lengths };
+            return { ...shared, type: EInputTypes.TextArea, rows: 2, required, ...lengths };
         case ExcelDataType.WholeNumber:
-            return { ...shared, type: "number", required, decimals: 0, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, decimals: 0, ...limits };
         case ExcelDataType.Decimal:
-            return { ...shared, type: "number", required, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, ...limits };
         case ExcelDataType.Amount:
-            return { ...shared, type: "number", required, decimals: 2, fixedDecimals: true, grouping: true, ...limits };
+            return { ...shared, type: EInputTypes.Number, required, decimals: 2, fixedDecimals: true, grouping: true, ...limits };
         case ExcelDataType.Date:
-            return { ...shared, type: "date", required };
+            return { ...shared, type: EInputTypes.Date, required };
         case ExcelDataType.DateTime:
-            return { ...shared, type: "text", required, pattern: MOMENT_PATTERN, placeholder: "2026-09-29 14:30" };
+            return { ...shared, type: EInputTypes.Text, required, pattern: MOMENT_PATTERN, placeholder: "2026-09-29 14:30" };
         case ExcelDataType.Time:
-            return { ...shared, type: "time", required };
+            return { ...shared, type: EInputTypes.Time, required };
         case ExcelDataType.YesNo:
-            return { ...shared, type: "dropdown", required, options: YES_NO, searchable: false };
+            return { ...shared, type: EInputTypes.Dropdown, required, options: YES_NO, searchable: false };
         default:
-            return { ...shared, type: "text", required, ...lengths };
+            return { ...shared, type: EInputTypes.Text, required, ...lengths };
     }
 }
 /** Every column of a sheet as the inputs of one editor row, in the order they read. */

package/dist/Helpers/FileAdapter.d.ts

@@ -0,0 +1,78 @@
+import type { ApiModuleValue, ApiResult } from "../Interfaces/ApiInterfaces.ts";
+import type { FileCallOptions, FileCategoryInfo, FileCopy, FileOwner, FileUpload, OwnerFiles, PictureType, StoredFile } from "../Interfaces/FileInterfaces.ts";
+export declare abstract class FileAdapter {
+    /** The owner's files and what their category takes, `canWrite` included. */
+    abstract list(owner: FileOwner<ApiModuleValue>, options?: FileCallOptions): Promise<ApiResult<OwnerFiles>>;
+    /**
+     * Each owner's picture, in the order asked (null where an owner has none): a page's rows in one call. At most
+     * `maxOwners` at a time; `primaryPictures` splits a longer list.
+     */
+    abstract primaries(module: ApiModuleValue, category: string, ownerIds: readonly string[], options?: FileCallOptions): Promise<ApiResult<(StoredFile | null)[]>>;
+    /** Stores one file for the owner and answers it as stored. */
+    abstract upload(owner: FileOwner<ApiModuleValue>, upload: FileUpload, options?: FileCallOptions): Promise<ApiResult<StoredFile>>;
+    /** Makes one of the owner's files its picture, or none (`null`). */
+    abstract setPrimary(owner: FileOwner<ApiModuleValue>, fileId: string | null, options?: FileCallOptions): Promise<ApiResult<unknown>>;
+    /** A new name for one of the owner's files; the backend keeps the extension of what the file really is. */
+    abstract rename(owner: FileOwner<ApiModuleValue>, fileId: string, name: string, options?: FileCallOptions): Promise<ApiResult<unknown>>;
+    /** Deletes one of the owner's files. */
+    abstract remove(owner: FileOwner<ApiModuleValue>, fileId: string, options?: FileCallOptions): Promise<ApiResult<unknown>>;
+    /** The address an `<img>`, a link or the viewer opens the file by. */
+    abstract fileUrl(file: StoredFile, copy: FileCopy): string;
+    /**
+     * The address of the image editor module (`nexus-image-editor`, an ES module) as this backend serves it, versioned,
+     * so `loadImageEditor` can import it. Rejects with an `Error` in plain words when it is not there.
+     */
+    abstract editorModuleUrl(signal?: AbortSignal): Promise<string>;
+    /** The most owners one `primaries` call takes. */
+    get maxOwners(): number;
+}
+/** One owner's key, for caches and listeners: the same module, category and id are the same owner. */
+export declare const fileOwnerKey: (owner: FileOwner<ApiModuleValue>) => string;
+/** Whether a category takes anything that is not a picture: its files are a document list, not a gallery. */
+export declare const takesDocuments: (category: Pick<FileCategoryInfo, "types">) => boolean;
+/** What a file input offers for a category: its MIME types. */
+export declare const acceptOf: (category: Pick<FileCategoryInfo, "types">) => string;
+/** A file's kind in a word, for a list: "JPEG", "PDF". */
+export declare function fileKindName(contentType: string): string;
+/** "JPEG, PNG or WebP" for a category's types, as a sentence names them. */
+export declare function fileKindsSentence(types: readonly string[]): string;
+/** A size in words: "5 MB". */
+export declare const fileSizeText: (bytes: number) => string;
+/**
+ * What a stored picture may be when the backend does not say (Drive's own defaults): its longest side in pixels, the
+ * highest quality in percent, and the most bytes. A company that hosts the site on its own machine raises Drive's
+ * settings, and the browser follows what Drive's List answers.
+ */
+export declare const PICTURE_LIMITS: {
+    readonly maxSide: 1920;
+    readonly quality: 80;
+    readonly maxBytes: number;
+};
+/**
+ * A category's limits for a stored picture: what the backend said, else `PICTURE_LIMITS`; the bytes never above the
+ * category's own `maxBytes`, the quality at most 100.
+ */
+export declare function pictureLimits(category: Pick<FileCategoryInfo, "maxBytes"> & Partial<Pick<FileCategoryInfo, "pictureMaxSide" | "pictureQuality" | "pictureMaxBytes">>): {
+    maxSide: number;
+    quality: number;
+    maxBytes: number;
+};
+/**
+ * Why a chosen file would be refused, before it is sent: a kind the category does not take, or larger than it takes -
+ * for a picture, the category's picture limit (`pictureLimits`). The backend checks the bytes again; this only spares
+ * the person an upload that cannot succeed. Null when it fits.
+ */
+export declare function fileRefusal(category: Pick<FileCategoryInfo, "types" | "maxBytes"> & Partial<Pick<FileCategoryInfo, "pictureMaxSide" | "pictureQuality" | "pictureMaxBytes">>, file: Pick<Blob, "type" | "size">, name: string): string | null;
+/**
+ * A picture's kind read from its first bytes - JPEG, PNG or WebP - for a file the browser could not type (none, or
+ * `application/octet-stream`: a phone's share, a file dragged from another app, a name with no extension), so it still
+ * goes through the editor. Null for anything
+ * else, which is left to the backend (it reads the bytes too).
+ */
+export declare function sniffPictureType(file: Blob): Promise<PictureType | null>;
+/** A chosen file with its kind: the browser's, else a picture's read from its bytes (`sniffPictureType`), else as it was. */
+export declare function typedFile(file: File): Promise<File>;
+/** How many more files the owner keeps: never below 0. */
+export declare const roomLeft: (files: OwnerFiles) => number;
+/** The name a picture made by the editor is kept by: the chosen file's name with the saved kind's extension. */
+export declare function pictureName(name: string | null | undefined, type: string, fallback?: string): string;

package/dist/Helpers/FileAdapter.js

@@ -0,0 +1,102 @@
+import { isPictureType } from "../Interfaces/FileInterfaces.js";
+import { chatFileSize } from "./ChatHelpers.js";
+/*
+ * Where an owner's files are kept. `FileAdapter` is the class an app implements for its own file backend;
+ * `NexusDriveAdapter` (nexus-shared/client) is the Nexus Drive and runs when nothing is registered - the same
+ * arrangement as `ApiModules` / `NexusApiModules` and `ExcelBackend` / `NexusExcelBackend`. The picture input, the
+ * gallery, the document list and the picture column call nothing else, so a page that declares pictures never names
+ * a backend.
+ *
+ * Every call answers an `ApiResult` and never throws for a refused or failed request, like `api`. None shows a toast:
+ * the panel that asked says what happened, once.
+ */
+export class FileAdapter {
+    /** The most owners one `primaries` call takes. */
+    get maxOwners() {
+        return 200;
+    }
+}
+/** One owner's key, for caches and listeners: the same module, category and id are the same owner. */
+export const fileOwnerKey = (owner) => `${String(owner.module)}|${owner.category}|${owner.ownerId}`;
+/** Whether a category takes anything that is not a picture: its files are a document list, not a gallery. */
+export const takesDocuments = (category) => category.types.some(type => !isPictureType(type));
+/** What a file input offers for a category: its MIME types. */
+export const acceptOf = (category) => category.types.join(",");
+/** A file's kind in a word, for a list: "JPEG", "PDF". */
+export function fileKindName(contentType) {
+    const kind = contentType.split("/")[1] ?? contentType;
+    return kind === "jpeg" ? "JPEG" : kind.toUpperCase();
+}
+/** "JPEG, PNG or WebP" for a category's types, as a sentence names them. */
+export function fileKindsSentence(types) {
+    const names = types.map(type => (type === "image/webp" ? "WebP" : fileKindName(type)));
+    if (names.length <= 1)
+        return names[0] ?? "";
+    return `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+}
+/** A size in words: "5 MB". */
+export const fileSizeText = (bytes) => chatFileSize(bytes);
+/**
+ * What a stored picture may be when the backend does not say (Drive's own defaults): its longest side in pixels, the
+ * highest quality in percent, and the most bytes. A company that hosts the site on its own machine raises Drive's
+ * settings, and the browser follows what Drive's List answers.
+ */
+export const PICTURE_LIMITS = { maxSide: 1920, quality: 80, maxBytes: 300 * 1024 };
+/**
+ * A category's limits for a stored picture: what the backend said, else `PICTURE_LIMITS`; the bytes never above the
+ * category's own `maxBytes`, the quality at most 100.
+ */
+export function pictureLimits(category) {
+    const positive = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : null);
+    const bytes = positive(category.pictureMaxBytes) ?? PICTURE_LIMITS.maxBytes;
+    return {
+        maxSide: positive(category.pictureMaxSide) ?? PICTURE_LIMITS.maxSide,
+        quality: Math.min(100, positive(category.pictureQuality) ?? PICTURE_LIMITS.quality),
+        maxBytes: category.maxBytes > 0 ? Math.min(bytes, category.maxBytes) : bytes,
+    };
+}
+/**
+ * Why a chosen file would be refused, before it is sent: a kind the category does not take, or larger than it takes -
+ * for a picture, the category's picture limit (`pictureLimits`). The backend checks the bytes again; this only spares
+ * the person an upload that cannot succeed. Null when it fits.
+ */
+export function fileRefusal(category, file, name) {
+    if (file.type && !category.types.includes(file.type))
+        return `"${name}" is not a ${fileKindsSentence(category.types)} file.`;
+    const limit = isPictureType(file.type) ? pictureLimits(category).maxBytes : category.maxBytes;
+    if (limit > 0 && file.size > limit)
+        return `"${name}" is larger than the ${fileSizeText(limit)} this takes.`;
+    return null;
+}
+/**
+ * A picture's kind read from its first bytes - JPEG, PNG or WebP - for a file the browser could not type (none, or
+ * `application/octet-stream`: a phone's share, a file dragged from another app, a name with no extension), so it still
+ * goes through the editor. Null for anything
+ * else, which is left to the backend (it reads the bytes too).
+ */
+export async function sniffPictureType(file) {
+    const head = new Uint8Array(await file.slice(0, 12).arrayBuffer());
+    const text = (from, to) => String.fromCharCode(...head.subarray(from, to));
+    if (head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff)
+        return "image/jpeg";
+    if (head.length >= 8 && [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every((byte, at) => head[at] === byte))
+        return "image/png";
+    if (head.length >= 12 && text(0, 4) === "RIFF" && text(8, 12) === "WEBP")
+        return "image/webp";
+    return null;
+}
+/** A chosen file with its kind: the browser's, else a picture's read from its bytes (`sniffPictureType`), else as it was. */
+export async function typedFile(file) {
+    if (file.type && file.type !== "application/octet-stream")
+        return file;
+    const type = await sniffPictureType(file);
+    return type ? new File([file], file.name, { type, lastModified: file.lastModified }) : file;
+}
+/** How many more files the owner keeps: never below 0. */
+export const roomLeft = (files) => Math.max(0, files.category.maxCount - files.files.length);
+/** The name a picture made by the editor is kept by: the chosen file's name with the saved kind's extension. */
+export function pictureName(name, type, fallback = "Picture") {
+    const base = (name ?? "").replace(/\.[A-Za-z][A-Za-z0-9]{0,3}$/, "").trim() || fallback;
+    const extension = type === "image/png" ? "png" : type === "image/webp" ? "webp" : "jpg";
+    return `${base}.${extension}`;
+}

package/dist/Helpers/FilePrimaries.d.ts

@@ -0,0 +1,48 @@
+import type { ApiModuleValue, ApiResult } from "../Interfaces/ApiInterfaces.ts";
+import type { FileOwner, StoredFile } from "../Interfaces/FileInterfaces.ts";
+/** Reads several owners' pictures, in the order asked: `FileAdapter.primaries`. */
+export type PrimariesReader = (module: ApiModuleValue, category: string, ownerIds: readonly string[]) => Promise<ApiResult<(StoredFile | null)[]>>;
+export interface PrimaryPicturesOptions {
+    /** The most owners one call takes, or a function asked when a batch is sent. Default 200, the Nexus Drive's limit. */
+    batchSize?: number | (() => number);
+    /** How long asks are gathered before they are sent, in milliseconds. Default 0: the asks of one render. */
+    delay?: number;
+    /** How long a refused or failed read is kept as "no picture" before an ask reads again, in milliseconds. Default 30000. */
+    retryAfter?: number;
+}
+export declare class PrimaryPictures {
+    private readonly read;
+    private readonly batchSize;
+    private readonly delay;
+    private readonly retryAfter;
+    /** Answers kept: a file, or null for "no picture". A key that is missing has not been read. */
+    private readonly known;
+    /** Reads under way, so two thumbnails of one owner ask once. */
+    private readonly pending;
+    /** Asks gathered per module and category, not sent yet. */
+    private readonly queue;
+    private readonly listeners;
+    /** Owners whose last read failed, with the time an ask may read again. Their `known` answer is null until then. */
+    private readonly failedUntil;
+    /** Bumped by `clear`, so an answer that comes back after it is not kept. */
+    private generation;
+    private timer;
+    constructor(read: PrimariesReader, options?: PrimaryPicturesOptions);
+    /** The owner's picture as kept: a file, `null` for none, `undefined` when it has not been read. */
+    peek(owner: FileOwner<ApiModuleValue>): StoredFile | null | undefined;
+    /** The owner's picture, read with the other asks of this moment unless it is kept already. */
+    get(owner: FileOwner<ApiModuleValue>): Promise<StoredFile | null>;
+    /** Writes in what a change on this page made the owner's picture, and tells its thumbnails. */
+    set(owner: FileOwner<ApiModuleValue>, file: StoredFile | null): void;
+    /** Forgets the owner's picture, so the next ask reads it again. */
+    forget(owner: FileOwner<ApiModuleValue>): void;
+    /** Forgets every kept picture: after a sign-out, or a reload of the whole page's data. */
+    clear(): void;
+    /** Calls `listener` whenever the owner's kept picture changes. Answers the function that stops it. */
+    subscribe(owner: FileOwner<ApiModuleValue>, listener: () => void): () => void;
+    /** Whether the owner's last read failed and its wait is over: the next ask reads again. */
+    private mayRetry;
+    private notify;
+    private flush;
+    private send;
+}

package/dist/Helpers/FilePrimaries.js

@@ -0,0 +1,138 @@
+import { fileOwnerKey } from "./FileAdapter.js";
+export class PrimaryPictures {
+    read;
+    batchSize;
+    delay;
+    retryAfter;
+    /** Answers kept: a file, or null for "no picture". A key that is missing has not been read. */
+    known = new Map();
+    /** Reads under way, so two thumbnails of one owner ask once. */
+    pending = new Map();
+    /** Asks gathered per module and category, not sent yet. */
+    queue = new Map();
+    listeners = new Map();
+    /** Owners whose last read failed, with the time an ask may read again. Their `known` answer is null until then. */
+    failedUntil = new Map();
+    /** Bumped by `clear`, so an answer that comes back after it is not kept. */
+    generation = 0;
+    timer = null;
+    constructor(read, options = {}) {
+        this.read = read;
+        const size = options.batchSize ?? 200;
+        this.batchSize = () => Math.max(1, typeof size === "function" ? size() : size);
+        this.delay = Math.max(0, options.delay ?? 0);
+        this.retryAfter = Math.max(0, options.retryAfter ?? 30_000);
+    }
+    /** The owner's picture as kept: a file, `null` for none, `undefined` when it has not been read. */
+    peek(owner) {
+        const key = fileOwnerKey(owner);
+        if (this.mayRetry(key))
+            return undefined;
+        return this.known.get(key);
+    }
+    /** The owner's picture, read with the other asks of this moment unless it is kept already. */
+    get(owner) {
+        const key = fileOwnerKey(owner);
+        if (this.mayRetry(key)) {
+            this.failedUntil.delete(key);
+            this.known.delete(key);
+        }
+        if (this.known.has(key))
+            return Promise.resolve(this.known.get(key) ?? null);
+        const pending = this.pending.get(key);
+        if (pending)
+            return pending;
+        const waiting = { owner, resolve: () => undefined, generation: this.generation };
+        const asked = new Promise(resolve => {
+            waiting.resolve = resolve;
+        });
+        waiting.asked = asked;
+        const group = `${String(owner.module)}|${owner.category}`;
+        const list = this.queue.get(group) ?? [];
+        list.push(waiting);
+        this.queue.set(group, list);
+        this.timer ??= setTimeout(() => this.flush(), this.delay);
+        this.pending.set(key, asked);
+        return asked;
+    }
+    /** Writes in what a change on this page made the owner's picture, and tells its thumbnails. */
+    set(owner, file) {
+        const key = fileOwnerKey(owner);
+        this.failedUntil.delete(key);
+        this.known.set(key, file);
+        this.notify(key);
+    }
+    /** Forgets the owner's picture, so the next ask reads it again. */
+    forget(owner) {
+        const key = fileOwnerKey(owner);
+        this.failedUntil.delete(key);
+        this.known.delete(key);
+        this.notify(key);
+    }
+    /** Forgets every kept picture: after a sign-out, or a reload of the whole page's data. */
+    clear() {
+        this.generation++;
+        this.known.clear();
+        this.failedUntil.clear();
+        // Reads still under way were asked for the person before; a `get` after this asks again.
+        this.pending.clear();
+        for (const key of this.listeners.keys())
+            this.notify(key);
+    }
+    /** Calls `listener` whenever the owner's kept picture changes. Answers the function that stops it. */
+    subscribe(owner, listener) {
+        const key = fileOwnerKey(owner);
+        const set = this.listeners.get(key) ?? new Set();
+        set.add(listener);
+        this.listeners.set(key, set);
+        return () => {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(key);
+        };
+    }
+    /** Whether the owner's last read failed and its wait is over: the next ask reads again. */
+    mayRetry(key) {
+        const until = this.failedUntil.get(key);
+        return until !== undefined && Date.now() >= until;
+    }
+    notify(key) {
+        for (const listener of [...(this.listeners.get(key) ?? [])])
+            listener();
+    }
+    flush() {
+        this.timer = null;
+        const groups = [...this.queue.values()];
+        this.queue.clear();
+        for (const waiting of groups) {
+            const size = this.batchSize();
+            for (let start = 0; start < waiting.length; start += size)
+                void this.send(waiting.slice(start, start + size));
+        }
+    }
+    async send(batch) {
+        const first = batch[0].owner;
+        const answer = await this.read(first.module, first.category, batch.map(item => item.owner.ownerId)).catch(() => ({ ok: false }));
+        batch.forEach((item, index) => {
+            const key = fileOwnerKey(item.owner);
+            if (this.pending.get(key) === item.asked)
+                this.pending.delete(key);
+            const current = item.generation === this.generation;
+            if (!answer.ok) {
+                // Kept as no picture for a while, so the rows that draw again do not each ask again; then an ask reads again.
+                if (current && !this.known.has(key)) {
+                    this.known.set(key, null);
+                    this.failedUntil.set(key, Date.now() + this.retryAfter);
+                    this.notify(key);
+                }
+                return item.resolve(null);
+            }
+            const file = answer.result?.[index] ?? null;
+            if (current && !this.known.has(key)) {
+                this.known.set(key, file);
+                this.notify(key);
+            }
+            item.resolve(current ? (this.known.get(key) ?? file) : file);
+        });
+    }
+}

package/dist/Helpers/FormConfirm.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from "react";
+import type { PopupSize } from "../Components/Layouts/Popup.tsx";
+import type { FormConfirmDetails, FormConfirmParams, FormValues } from "../Interfaces/FormInterfaces.ts";
+import type { TableColumn, TableRow } from "../Interfaces/TableInterfaces.ts";
+/** A run of neighbouring columns with one `group` (`group` null for columns with none): one section of a record's details. */
+export interface CrudDetailsRun<TRow extends TableRow = TableRow> {
+    group: string | null;
+    columns: TableColumn<TRow>[];
+}
+/**
+ * A record's fields in sections: each run of neighbouring columns that name the same `group` is one section under that
+ * heading, and a run of columns with no group is a section with none. A group named again further on starts a new run,
+ * as a table's band does. An empty group name counts as none.
+ */
+export declare function crudDetailsRuns<TRow extends TableRow>(columns: readonly TableColumn<TRow>[]): CrudDetailsRun<TRow>[];
+/** Whether the form asks before this save: a `confirm` is given, and its `when` holds for the values (or it has none). */
+export declare function formConfirmAsks<TValues extends FormValues>(confirm: FormConfirmParams<TValues> | null | undefined, values: TValues): boolean;
+/** The question a form asks before a save, with every text settled for the values and the body to be sent. */
+export interface FormConfirmQuestion {
+    title: ReactNode;
+    message: ReactNode;
+    details: FormConfirmDetails | null;
+    confirmLabel: ReactNode;
+    cancelLabel: ReactNode;
+    size: PopupSize;
+}
+/**
+ * The question for these values and this body: each text worked out from them, the details drawn when given (a null
+ * answer draws none), "Confirm and save" and "Back to the form" unless given, and the width `lg` with details (two
+ * fields to a line) or `sm` without, unless given. A rule that throws throws here, before anything is shown.
+ */
+export declare function formConfirmQuestion<TValues extends FormValues>(confirm: FormConfirmParams<TValues>, values: TValues, body: unknown): FormConfirmQuestion;

package/dist/Helpers/FormConfirm.js

@@ -0,0 +1,40 @@
+/**
+ * A record's fields in sections: each run of neighbouring columns that name the same `group` is one section under that
+ * heading, and a run of columns with no group is a section with none. A group named again further on starts a new run,
+ * as a table's band does. An empty group name counts as none.
+ */
+export function crudDetailsRuns(columns) {
+    const runs = [];
+    for (const column of columns) {
+        const group = column.group || null;
+        const last = runs[runs.length - 1];
+        if (last && last.group === group)
+            last.columns.push(column);
+        else
+            runs.push({ group, columns: [column] });
+    }
+    return runs;
+}
+/** Whether the form asks before this save: a `confirm` is given, and its `when` holds for the values (or it has none). */
+export function formConfirmAsks(confirm, values) {
+    if (!confirm)
+        return false;
+    return confirm.when ? Boolean(confirm.when(values)) : true;
+}
+const settle = (text, values, body) => typeof text === "function" ? text(values, body) : text;
+/**
+ * The question for these values and this body: each text worked out from them, the details drawn when given (a null
+ * answer draws none), "Confirm and save" and "Back to the form" unless given, and the width `lg` with details (two
+ * fields to a line) or `sm` without, unless given. A rule that throws throws here, before anything is shown.
+ */
+export function formConfirmQuestion(confirm, values, body) {
+    const details = confirm.details?.(values, body) ?? null;
+    return {
+        title: settle(confirm.title, values, body),
+        message: confirm.message === undefined ? null : settle(confirm.message, values, body),
+        details,
+        confirmLabel: confirm.confirmLabel === undefined ? "Confirm and save" : settle(confirm.confirmLabel, values, body),
+        cancelLabel: confirm.cancelLabel ?? "Back to the form",
+        size: confirm.size ?? (details ? "lg" : "sm"),
+    };
+}

package/dist/Helpers/FormStore.d.ts

@@ -1,4 +1,5 @@
 import type { FormErrors, FormRuleResult, FormValues, InputParams, InputValidationContext } from "../Interfaces/FormInterfaces.ts";
+import { type InputMemoryStorage } from "./InputMemory.ts";
 export interface FormStoreOptions<TValues extends FormValues = FormValues> {
     inputs: readonly InputParams[];
     validate?(values: TValues): FormRuleResult;
@@ -58,6 +59,21 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     private inputByName;
     private values;
     private initial;
+    /** The values the last load was given, as given: an input they name with a value is the form's own, never remembered. */
+    private given;
+    /** Where remembered inputs (`remember`) are read and kept; set by the form that draws this store, in the browser. */
+    private memory;
+    /** Pickers asked whether they still offer a remembered value; the next opening (a load, a reset) or a submit stops it. */
+    private memoryRound;
+    /** The inputs whose picker is being asked: drawn loading, and a change to one (the person's pick, code) ends its ask. */
+    private asking;
+    /** The values memory opened inputs on: an opening that finds nothing (a reset after the choice went) takes its own back. */
+    private fromMemory;
+    /**
+     * The values a load (or a reset, a draft) is working out, while it works them out: what `get` answers then, so an
+     * input's live `hidden` (`showWhen`) is judged on the values the form opens with, never on the ones it had before.
+     */
+    private reading;
     private isStarted;
     private ruleErrors;
     /** Rows inputs are checked when asked: 10,000 rows on every keystroke would be slow, and the rows check themselves. */
@@ -87,6 +103,8 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     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;
+    /** What a choice input reported beside the value the user picked last (`pickedItem`): its item, kept with that value. */
+    private picked;
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     private quiet;
     private unannounced;
@@ -100,6 +118,8 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     /** Every value, plus the fields the record came with. The same object until something changes; do not change it. */
     getValue(): TValues;
     get(name: string): unknown;
+    /** The params of the input of this name, as the form was given them; undefined for a name no input has. */
+    inputParams(name: string): InputParams | undefined;
     /** The values the form opened with, or saved last. */
     getInitial(): TValues;
     /** Only the values that differ from the ones the form opened with or saved last. */
@@ -107,11 +127,23 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     /** The inputs whose values changed, in form order. */
     changedInputs(): string[];
     isChanged(): boolean;
+    /**
+     * Whether the changes are worth asking about before they are dropped (Cancel, closing a popup, leaving the page): a
+     * changed value of any input but a password or a one-time code (`keepsTyping`). A form where only those were typed is
+     * changed, and Save and its line say so, but nothing asks before it goes.
+     */
+    isWorthKeeping(): boolean;
     getStatus: () => FormStatus;
     /** The message an input shows for the form: a server's, the form's rule once the input was left or a submit ran, or its own rule after a submit its input missed. */
     shownError(name: string): string | undefined;
     /** The shown message, with the form's rule messages given, such as the ones before a change. */
     private shownWith;
+    /**
+     * The item a choice input reported with the value it holds now, when the user picked that value: a dropdown's option
+     * (its options, with `multiple`). `undefined` for a value loaded, set from code, or changed since - so what it answers
+     * always goes with the value. A CRUD names what a save joined from it (`crudJoinedNames`).
+     */
+    pickedItem(name: string): unknown;
     /** The input's own rule message for its value, whether it shows or not. */
     ruleError(name: string): string | null;
     /** The form's own rule message for an input, whether it shows or not. */
@@ -152,17 +184,21 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     /** Tells listeners about a quiet load. */
     announce(): void;
     private loadValues;
-    /** Brings back the values the form opened with or saved last, and clears every message. The draft goes too. */
+    /**
+     * Brings back the values the form opened with or saved last, and clears every message. The draft goes too. A
+     * remembered input opens on the choice kept now, so a form reset after a save starts on what was just saved.
+     */
     reset(): void;
     /** Sets a value from code. Its input shows it at once, and it counts as a change. */
     set(name: string, value: unknown): void;
     /** Sets several values from code, as one change. */
     setValues(values: Partial<TValues>): void;
     /**
-     * A value the user typed or picked, from the input rendered with `stamp`. An input that was replaced since (by a value
-     * from code, a load, or a reset) can still report its last value as it leaves; that value is ignored.
+     * A value the user typed or picked, from the input rendered with `stamp`, with what a choice input reported beside it
+     * (`item`: a dropdown's option, kept for `pickedItem`). An input that was replaced since (by a value from code, a load,
+     * or a reset) can still report its last value as it leaves; that value is ignored.
      */
-    input(name: string, value: unknown, stamp: string): void;
+    input(name: string, value: unknown, stamp: string, item?: unknown): void;
     /** Marks an input as left by the user: the form's rule messages on it show from now on. */
     touch(name: string): void;
     /**
@@ -199,6 +235,28 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
      * `extra` (from the server, such as a new id) is set on top.
      */
     commit(saved: TValues, extra?: Partial<TValues>): void;
+    /**
+     * @internal Whether the input's picker is being asked whether it still offers a remembered value: the input draws
+     * loading until it answers, the person picks, or the form opens again.
+     */
+    isRemembering(name: string): boolean;
+    /**
+     * @internal The browser storage remembered inputs read and keep (`InputLayoutParams.remember`), set by the form that
+     * draws this store once it is in the browser. Inputs the values left without one open on it at once (as the values
+     * the form opened with), a picker once it answers that it still offers the value; a form drawn on a server opened
+     * without it, so nothing differs while it hydrates.
+     */
+    attachMemory(storage: InputMemoryStorage | null): void;
+    /**
+     * Inputs that follow ones memory opened (`dependsOn`: a `compute.from`, `showWhen`, `spanWhen`, `labelWhen`, or a
+     * `narrowedBy`) draw again with their params read afresh, as after a change: a cell redraws only on its own bump.
+     */
+    private bumpFollowers;
+    /**
+     * @internal A save: each remembered input keeps the value saved (an empty one forgets), for the next form that asks -
+     * under the saved values' `per` value, and only where its `when` holds on them.
+     */
+    rememberSaved(values: TValues): void;
     /** @internal A save after which the form went back to its opening values (`resetOnSuccess`). */
     markSaved(): void;
     /** @internal While the values load, nothing typed is taken (`input`), and a submit waits (`SubmitForm`). */
@@ -210,10 +268,37 @@ export declare class FormStore<TValues extends FormValues = FormValues> {
     private indexInputs;
     /** Each input's value in the type the input reports; a missing one is the input's default. Other fields stay as they came. */
     private normalize;
+    /** Runs `work` with `get` answering from these values (a load's, a reset's, a draft's), and gives back its answer. */
+    private readingFrom;
+    /**
+     * The values with each remembered input the given values leave without one opened on the company's preferred value
+     * or the person's last choice (`rememberedOpeningNow`), its `when` and `per` read among these values; without storage
+     * (on a server, before the form is drawn) only a preferred value applies. A kept choice no longer offered is forgotten.
+     * A picker that must be asked first opens nothing now: it is asked, and its answer opens the input later
+     * (`askPickers`) - the round any earlier opening started stops here. An input memory opened before (a reset after a
+     * save, the storage arriving) that now opens on nothing takes the value the given values give it back.
+     */
+    private openRemembered;
+    /** Stops asking pickers about remembered values: their answers no longer open anything, and their inputs stop loading. */
+    private stopAskingPickers;
+    /**
+     * Asks each picker whether it still offers the remembered value (`findRememberedOpening`), the input drawn loading
+     * meanwhile. An answer forgets a choice no longer offered, and opens an offered one (`openAsked`) only while the input
+     * is still asked about - no pick, no value from code since - and the values it was judged on (`rememberDependencies`:
+     * the group that narrows it, the one it is kept per, its `when`) are still the form's: a group changed meanwhile opens
+     * nothing.
+     */
+    private askPickers;
+    /**
+     * A picker answered for a remembered value: the input opens on it, as the value the form opened with (not a change) -
+     * only while it is as the form opened it and still on the form. One the person typed in, or a draft gave back, keeps
+     * what it has.
+     */
+    private openAsked;
     /** Inputs that were not there, or were hidden, get their value in the input's type, as a load gives it. */
     private adoptNewInputs;
     private change;
-    /** The inputs whose `dependsOn` names any of `names`. */
+    /** The inputs whose `dependsOn` (or `narrowedBy`) names any of `names`. */
     private followersOf;
     private checkRule;
     private checkAllRules;