nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/FormStore.js

@@ -1,5 +1,8 @@
 import { deleteFormDraft, readFormDraft, writeFormDraft } from "./FormDrafts.js";
-import { initialInputValue, inputValuesEqual, isRowsInput, normalizeInputValue, validateInput } from "./InputParamsHelpers.js";
+import { isComputedInput } from "./InputConditions.js";
+import { formNarrowingNames, inputNarrowingsOf, isEmptyNarrowed, narrowedFollowers } from "./InputNarrowing.js";
+import { findRememberedOpening, forgetInputMemory, isEmptyInputValue, isPickerInput, readInputMemory, rememberDependencies, rememberedOpeningNow, writeInputMemory } from "./InputMemory.js";
+import { holdsValue, initialInputValue, inputValuesEqual, isRowsInput, keepsTyping, normalizeInputValue, validateInput } from "./InputParamsHelpers.js";
 const INITIAL_STATUS = {
     changed: false,
     submitting: false,
@@ -40,6 +43,21 @@ export class FormStore {
     inputByName = new Map();
     values = {};
     initial = {};
+    /** The values the last load was given, as given: an input they name with a value is the form's own, never remembered. */
+    given = {};
+    /** Where remembered inputs (`remember`) are read and kept; set by the form that draws this store, in the browser. */
+    memory = null;
+    /** Pickers asked whether they still offer a remembered value; the next opening (a load, a reset) or a submit stops it. */
+    memoryRound = null;
+    /** The inputs whose picker is being asked: drawn loading, and a change to one (the person's pick, code) ends its ask. */
+    asking = new Set();
+    /** The values memory opened inputs on: an opening that finds nothing (a reset after the choice went) takes its own back. */
+    fromMemory = new Map();
+    /**
+     * 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.
+     */
+    reading = null;
     isStarted = false;
     // Messages: an input's own rules, the form's rule, a server's, and rule messages the form shows for its inputs.
     ruleErrors = new Map();
@@ -72,6 +90,8 @@ export class FormStore {
     draftDropped = false;
     /** An input reported a value while the values loaded and was refused: it is drawn again from the store when loading ends. */
     refusedWhileLoading = false;
+    /** What a choice input reported beside the value the user picked last (`pickedItem`): its item, kept with that value. */
+    picked = new Map();
     /** A load during a render tells nobody; `announce` does, once the form has mounted. */
     quiet = false;
     unannounced = false;
@@ -92,7 +112,13 @@ export class FormStore {
         return this.values;
     }
     get(name) {
-        return this.values[name];
+        return this.reading ? this.reading[name] : this.values[name];
+    }
+    /** The params of the input of this name, as the form was given them; undefined for a name no input has. */
+    inputParams(name) {
+        if (!this.inputByName.size && this.options.inputs.length)
+            this.indexInputs();
+        return this.inputByName.get(name);
     }
     /** The values the form opened with, or saved last. */
     getInitial() {
@@ -112,6 +138,19 @@ export class FormStore {
     isChanged() {
         return this.changedNames.size > 0;
     }
+    /**
+     * 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() {
+        for (const name of this.changedNames) {
+            const params = this.inputParams(name);
+            if (!params || keepsTyping(params))
+                return true;
+        }
+        return false;
+    }
     getStatus = () => this.status;
     /** 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) {
@@ -129,12 +168,21 @@ export class FormStore {
             return this.ruleError(name) ?? undefined;
         return undefined;
     }
+    /**
+     * 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) {
+        const picked = this.picked.get(name);
+        return picked && inputValuesEqual(picked.value, this.values[name]) ? picked.item : undefined;
+    }
     /** The input's own rule message for its value, whether it shows or not. */
     ruleError(name) {
         if (this.staleRules.has(name)) {
             this.staleRules.delete(name);
             const params = this.inputByName.get(name);
-            const message = params && !params.hidden && !this.options.locked ? validateInput(params, this.values[name], this.options.context) : null;
+            const message = params && !params.hidden && !isComputedInput(params) && !this.options.locked ? validateInput(params, this.values[name], this.options.context) : null;
             if (message)
                 this.ruleErrors.set(name, message);
             else
@@ -152,7 +200,7 @@ export class FormStore {
     }
     /** Inputs whose values break a rule, their own or the form's, in form order. Inputs on the page may find more, such as text that is not a date yet. */
     problems() {
-        return this.options.inputs.filter(params => !params.hidden && (this.ruleError(params.name) || this.crossErrors.has(params.name))).map(params => params.name);
+        return this.options.inputs.filter(params => !params.hidden && !isComputedInput(params) && (this.ruleError(params.name) || this.crossErrors.has(params.name))).map(params => params.name);
     }
     /** Whether every value passes, as far as the values tell. `validate()` also asks the inputs on the page. */
     isValid() {
@@ -247,7 +295,10 @@ export class FormStore {
     loadValues(values, keepChanged, draft) {
         if (!this.inputByName.size && this.options.inputs.length)
             this.indexInputs();
-        const next = this.normalize(values);
+        this.given = values;
+        // A load opens afresh: what memory opened before belongs to the values it replaces.
+        this.fromMemory.clear();
+        const next = this.openRemembered(this.normalize(values), values);
         const merge = keepChanged && this.isStarted;
         const conflicts = [];
         let current = next;
@@ -301,8 +352,12 @@ export class FormStore {
             this.scheduleDraft();
         return conflicts;
     }
-    /** 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() {
+        this.initial = this.openRemembered({ ...this.initial }, this.given);
         this.values = { ...this.initial };
         this.changedNames.clear();
         this.generation++;
@@ -323,10 +378,26 @@ export class FormStore {
         this.change(Object.entries(values), "code");
     }
     /**
-     * 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.
+     * Values a person set through another input - one worked out from them and typed in (`compute.solve`) - as one change.
+     * Their inputs show them at once, as values from code do, and they are taken as the person's own: the form's
+     * `onFieldChange` runs for them, and inputs narrowed by them lose what they picked. Nothing is taken while the values
+     * load. Answers whether anything changed.
+     */
+    setFromPerson(values) {
+        if (this.status.loading) {
+            this.refusedWhileLoading = true;
+            return false;
+        }
+        const before = this.values;
+        this.change(Object.entries(values), "person");
+        return this.values !== before;
+    }
+    /**
+     * 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, value, stamp) {
+    input(name, value, stamp, item) {
         if (stamp !== this.stamp(name))
             return;
         // Nothing is taken while the values load, not even from an input whose `disabled` was taken off by hand: the
@@ -335,6 +406,10 @@ export class FormStore {
             this.refusedWhileLoading = true;
             return;
         }
+        if (item === undefined)
+            this.picked.delete(name);
+        else
+            this.picked.set(name, { value, item });
         this.change([[name, value]], "input");
     }
     /** Marks an input as left by the user: the form's rule messages on it show from now on. */
@@ -358,7 +433,8 @@ export class FormStore {
             if (!text)
                 continue;
             const params = this.inputByName.get(name);
-            if (params && !params.hidden)
+            // A worked-out input is never typed in, so a message naming it is the form's.
+            if (params && !params.hidden && !isComputedInput(params))
                 this.serverErrors.set(name, text);
             else
                 others.push(text);
@@ -454,6 +530,8 @@ export class FormStore {
     }
     /** @internal A submit starts: messages from the last answer go. */
     beginSubmit() {
+        // What is in the form is what is saved: a remembered value a picker answers for now would come in after it.
+        this.stopAskingPickers();
         const shown = this.shownSnapshot();
         this.serverErrors.clear();
         this.serverMessage = null;
@@ -474,6 +552,8 @@ export class FormStore {
         if (extra) {
             for (const [name, value] of Object.entries(extra)) {
                 const params = this.inputByName.get(name);
+                if (isComputedInput(params))
+                    continue;
                 const next = params && !params.hidden ? normalizeInputValue(params, value) : value;
                 if (inputValuesEqual(this.values[name], next))
                     continue;
@@ -491,6 +571,67 @@ export class FormStore {
             this.emit(null);
         this.flushDraft();
     }
+    /**
+     * @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) {
+        return this.asking.has(name);
+    }
+    /**
+     * @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) {
+        if (this.memory === storage)
+            return;
+        this.memory = storage;
+        if (!storage || !this.isStarted)
+            return;
+        const opened = this.openRemembered({ ...this.initial }, this.given);
+        const changed = [];
+        for (const params of this.options.inputs) {
+            const { name } = params;
+            // Only an input still as the form opened it: one typed in (or restored from a draft) keeps what it has.
+            if (!params.remember || isComputedInput(params) || this.changedNames.has(name) || inputValuesEqual(opened[name], this.initial[name]))
+                continue;
+            this.initial = { ...this.initial, [name]: opened[name] };
+            this.values = { ...this.values, [name]: opened[name] };
+            this.nextRevision(name);
+            this.bump(name);
+            changed.push(name);
+        }
+        if (!changed.length)
+            return;
+        this.checkAllRules();
+        this.checkCross();
+        this.bumpFollowers(changed);
+        this.emit(null);
+    }
+    /**
+     * 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.
+     */
+    bumpFollowers(names) {
+        for (const name of this.followersOf(names))
+            if (!names.includes(name))
+                this.bump(name);
+    }
+    /**
+     * @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) {
+        if (!this.memory)
+            return;
+        const read = (name) => values[name];
+        for (const params of this.options.inputs) {
+            if (params.remember && !params.hidden && !isComputedInput(params))
+                writeInputMemory(this.memory, params, read(params.name), read);
+        }
+    }
     /** @internal A save after which the form went back to its opening values (`resetOnSuccess`). */
     markSaved() {
         this.patchStatus({ submitting: false, savedAt: Date.now() });
@@ -521,20 +662,160 @@ export class FormStore {
     /** Each input's value in the type the input reports; a missing one is the input's default. Other fields stay as they came. */
     normalize(values) {
         const result = { ...values };
-        for (const params of this.options.inputs) {
-            // A hidden input's value stays in the data as it was.
-            if (params.hidden)
-                continue;
+        // A worked-out input (`compute`) holds no value: a field the data has under its name is not the form's to send.
+        for (const params of this.options.inputs)
+            if (isComputedInput(params))
+                delete result[params.name];
+        const inputs = this.options.inputs.filter(params => holdsValue(params) && !isComputedInput(params));
+        // Which inputs are hidden is judged on these values: an input shown by another's value (`showWhen`) whose other input
+        // gets its value in this very load (its default, the record's). So every input is worked out as shown first...
+        for (const params of inputs)
             result[params.name] = params.name in values ? normalizeInputValue(params, values[params.name]) : initialInputValue(params);
+        // ...then a hidden input's value goes back to what the data held (a picture has none: the record keeps what it came with).
+        const hidden = this.readingFrom(result, () => inputs.filter(params => params.hidden));
+        for (const params of hidden) {
+            if (params.name in values)
+                result[params.name] = values[params.name];
+            else
+                delete result[params.name];
+        }
+        return result;
+    }
+    /** Runs `work` with `get` answering from these values (a load's, a reset's, a draft's), and gives back its answer. */
+    readingFrom(values, work) {
+        const before = this.reading;
+        this.reading = values;
+        try {
+            return work();
+        }
+        finally {
+            this.reading = before;
+        }
+    }
+    /**
+     * 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.
+     */
+    openRemembered(values, given) {
+        let result = values;
+        // The values as they open, in form order: a group opened on its kept value names the package kept for it.
+        const read = (name) => result[name];
+        const asks = [];
+        const set = (name, value) => {
+            if (result === values)
+                result = { ...values };
+            result[name] = value;
+        };
+        // Shown or hidden as the values being opened say, not as the store's previous ones do.
+        const shown = this.readingFrom(values, () => this.options.inputs.filter(params => params.remember && !params.hidden && holdsValue(params) && !isComputedInput(params)));
+        for (const params of shown) {
+            const { name } = params;
+            if (name in given && !isEmptyInputValue(params, given[name]))
+                continue;
+            // A picker is asked in the browser only, once the storage came: a server's draw never calls it or reads its cache.
+            if (!this.memory && isPickerInput(params))
+                continue;
+            const stored = this.memory ? readInputMemory(this.memory, params.remember, read) : undefined;
+            const opening = rememberedOpeningNow(params, stored, read);
+            if (opening.forget)
+                forgetInputMemory(this.memory, params.remember, read);
+            if (opening.ask)
+                asks.push({ params, stored });
+            if (opening.value !== undefined) {
+                const value = normalizeInputValue(params, opening.value);
+                set(name, value);
+                this.fromMemory.set(name, value);
+            }
+            else if (this.fromMemory.has(name)) {
+                // Still the value memory opened it on: the input's own comes back, so a choice no longer offered is not left in.
+                if (inputValuesEqual(result[name], this.fromMemory.get(name))) {
+                    set(name, name in given ? normalizeInputValue(params, given[name]) : initialInputValue(params));
+                }
+                this.fromMemory.delete(name);
+            }
         }
+        this.askPickers(asks, read);
         return result;
     }
+    /** Stops asking pickers about remembered values: their answers no longer open anything, and their inputs stop loading. */
+    stopAskingPickers() {
+        this.memoryRound?.abort();
+        this.memoryRound = null;
+        const asked = [...this.asking];
+        this.asking.clear();
+        for (const name of asked)
+            this.bump(name);
+    }
+    /**
+     * 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.
+     */
+    askPickers(asks, read) {
+        this.stopAskingPickers();
+        if (!asks.length)
+            return;
+        const round = new AbortController();
+        this.memoryRound = round;
+        const memory = this.memory;
+        for (const { params, stored } of asks) {
+            const { name } = params;
+            const judgedOn = rememberDependencies(params).map(other => [other, read(other)]);
+            this.asking.add(name);
+            this.bump(name);
+            void findRememberedOpening(params, stored, read, round.signal).then(opening => {
+                if (round.signal.aborted)
+                    return;
+                if (opening.forget)
+                    forgetInputMemory(memory, params.remember, read);
+                if (!this.asking.delete(name))
+                    return;
+                const still = judgedOn.every(([other, value]) => inputValuesEqual(this.values[other], value));
+                if (opening.value !== undefined && still)
+                    this.openAsked(name, opening.value);
+                else
+                    this.bump(name);
+            });
+        }
+    }
+    /**
+     * 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.
+     */
+    openAsked(name, value) {
+        const params = this.inputByName.get(name);
+        if (!params || params.hidden || !holdsValue(params) || isComputedInput(params) || this.changedNames.has(name)) {
+            this.bump(name);
+            return;
+        }
+        const next = normalizeInputValue(params, value);
+        this.fromMemory.set(name, next);
+        if (inputValuesEqual(this.values[name], next)) {
+            this.bump(name);
+            return;
+        }
+        this.initial = { ...this.initial, [name]: next };
+        this.values = { ...this.values, [name]: next };
+        this.nextRevision(name);
+        this.bump(name);
+        this.checkAllRules();
+        this.checkCross();
+        this.bumpFollowers([name]);
+        this.emit(null);
+    }
     /** Inputs that were not there, or were hidden, get their value in the input's type, as a load gives it. */
     adoptNewInputs(previous) {
         const before = new Map(previous.map(params => [params.name, params]));
         for (const params of this.options.inputs) {
             const old = before.get(params.name);
-            if (params.hidden || (old && !old.hidden))
+            if (params.hidden || !holdsValue(params) || isComputedInput(params) || (old && !old.hidden))
                 continue;
             const { name } = params;
             const value = name in this.values ? normalizeInputValue(params, this.values[name]) : initialInputValue(params);
@@ -547,20 +828,31 @@ export class FormStore {
                 this.changedNames.add(name);
         }
     }
-    change(entries, source) {
+    change(entries, changedBy) {
+        // A person's change through another input (`setFromPerson`) is written as code writes (its inputs mount again with
+        // it) and followed as typing is.
+        const source = changedBy === "code" ? "code" : "input";
+        const writtenAs = changedBy === "input" ? "input" : "code";
         const crossBefore = this.crossErrors;
         const shown = new Map();
         const remounted = new Set();
         const written = [];
+        /** Inputs a picker was asked about for a remembered value: this change is theirs now, and they stop loading. */
+        const unasked = [];
         const remember = (name) => {
             if (!shown.has(name))
                 shown.set(name, this.shownError(name));
         };
         const write = (name, value, from) => {
             const params = this.inputByName.get(name);
+            // A worked-out input holds no value: one set from code (or a draft, an `onFieldChange` patch) is not taken.
+            if (isComputedInput(params))
+                return;
             const next = params && !params.hidden && from === "code" ? normalizeInputValue(params, value) : value;
             if (inputValuesEqual(this.values[name], next))
                 return;
+            if (this.asking.delete(name))
+                unasked.push(name);
             remember(name);
             this.values = { ...this.values, [name]: next };
             if (from === "code" && params) {
@@ -578,7 +870,7 @@ export class FormStore {
             written.push(name);
         };
         for (const [name, value] of entries)
-            write(name, value, source);
+            write(name, value, writtenAs);
         if (!written.length)
             return;
         // Values derived from the ones the user changed, such as an amount from a quantity and a rate.
@@ -592,6 +884,44 @@ export class FormStore {
                             write(field, value, "code");
             }
         }
+        // An input whose options another narrows (`narrowedBy`) loses the value it picked among the other's old options when
+        // a person changes the other one; a value set from code (a load, a patch) is the code's to keep consistent. Down a
+        // chain too: a Country change clears the Region, and with it the District picked among that Region's (each input
+        // once, whatever order the form lists them in; one the person set in this same change keeps its value).
+        if (source === "input") {
+            const followers = narrowedFollowers(this.options.inputs, written, "form");
+            for (const name of followers) {
+                if (!isEmptyNarrowed(this.values[name]))
+                    write(name, null, "code");
+            }
+            // Rows whose inputs follow a form value (`from: "form"`, a line's Tags of the form's Store): every row loses what
+            // it picked among the old value's options, and down the row's own chain.
+            const changedNow = new Set([...written, ...followers]);
+            for (const params of this.options.inputs) {
+                if (!isRowsInput(params))
+                    continue;
+                const rowInputs = params.inputs ?? [];
+                if (!formNarrowingNames(rowInputs).some(name => changedNow.has(name)))
+                    continue;
+                const clear = narrowedFollowers(rowInputs, changedNow, "rows-of-form");
+                const rows = this.values[params.name];
+                if (!clear.length || !Array.isArray(rows))
+                    continue;
+                let touched = false;
+                const next = rows.map(row => {
+                    if (row === null || typeof row !== "object")
+                        return row;
+                    const filled = clear.filter(name => !isEmptyNarrowed(row[name]));
+                    if (!filled.length)
+                        return row;
+                    touched = true;
+                    // Each cleared as its input holds nothing: an empty list for a picker of several.
+                    return { ...row, ...Object.fromEntries(filled.map(name => [name, emptyRowValue(rowInputs, name)])) };
+                });
+                if (touched)
+                    write(params.name, next, "code");
+            }
+        }
         // Inputs that follow a changed one (`dependsOn`) draw again with their params read afresh, and their rule is asked
         // again: a getter may have just made one required, read-only or hidden.
         const followers = this.followersOf(written);
@@ -604,24 +934,30 @@ export class FormStore {
             if (!shown.has(name))
                 shown.set(name, this.shownWith(name, crossBefore));
         for (const [name, before] of shown)
-            if (remounted.has(name) || followers.has(name) || this.shownError(name) !== before)
+            if (remounted.has(name) || followers.has(name) || unasked.includes(name) || this.shownError(name) !== before)
                 this.bump(name);
         this.patchStatus({ changed: this.changedNames.size > 0, message: this.formMessage(), problems: this.problemList() });
-        this.emit(source === "input" ? written[0] : written.length === 1 ? written[0] : null);
+        this.emit(changedBy === "input" ? written[0] : written.length === 1 ? written[0] : null);
         // A change after a cancel is worth keeping again.
         if (source === "input")
             this.draftDropped = false;
         this.scheduleDraft();
     }
-    /** The inputs whose `dependsOn` names any of `names`. */
+    /**
+     * The inputs whose `dependsOn` (or `narrowedBy`) names any of `names`, and the rows inputs whose row inputs are narrowed
+     * by one of them `from: "form"`: their rows draw again with the form's value as it is now.
+     */
     followersOf(names) {
         const found = new Set();
         if (!names.length)
             return found;
         const changed = new Set(names);
-        for (const params of this.options.inputs)
-            if (params.dependsOn?.some(name => changed.has(name)))
+        for (const params of this.options.inputs) {
+            if (params.dependsOn?.some(name => changed.has(name)) || inputNarrowingsOf(params).some(narrowing => changed.has(narrowing.name)))
                 found.add(params.name);
+            else if (isRowsInput(params) && formNarrowingNames(params.inputs ?? []).some(name => changed.has(name)))
+                found.add(params.name);
+        }
         return found;
     }
     checkRule(name) {
@@ -631,7 +967,7 @@ export class FormStore {
             return;
         }
         this.staleRules.delete(name);
-        const message = params && !params.hidden && !this.options.locked ? validateInput(params, this.values[name], this.options.context) : null;
+        const message = params && !params.hidden && !isComputedInput(params) && !this.options.locked ? validateInput(params, this.values[name], this.options.context) : null;
         if (message)
             this.ruleErrors.set(name, message);
         else
@@ -657,7 +993,7 @@ export class FormStore {
                 if (!message)
                     continue;
                 const params = this.inputByName.get(name);
-                if (params && !params.hidden)
+                if (params && !params.hidden && !isComputedInput(params))
                     next.set(name, message);
                 else
                     others.push(message);
@@ -751,9 +1087,11 @@ export class FormStore {
         }
         const entries = [];
         const conflicts = [];
+        // An input the draft's own values show (its other input among them) is restored too.
+        const hidden = this.readingFrom({ ...this.values, ...draft.values }, () => new Set(this.options.inputs.filter(params => params.hidden).map(params => params.name)));
         for (const params of this.options.inputs) {
             const { name } = params;
-            if (params.hidden || !(name in draft.values) || this.changedNames.has(name))
+            if (hidden.has(name) || isComputedInput(params) || !(name in draft.values) || this.changedNames.has(name))
                 continue;
             const value = draft.values[name];
             if (sameData(value, this.values[name]))
@@ -770,3 +1108,8 @@ export class FormStore {
         this.patchStatus({ restored: { savedAt: draft.savedAt, names: entries.map(([name]) => name), conflicts }, draftSavedAt: draft.savedAt });
     }
 }
+/** A row input's value when nothing is picked: as the rows hold it (an empty list for a picker of several). */
+function emptyRowValue(rowInputs, name) {
+    const params = rowInputs.find(input => input.name === name);
+    return params ? normalizeInputValue(params, null) : null;
+}

package/dist/Helpers/InputConditions.d.ts

@@ -0,0 +1,56 @@
+import { type FormValues, type InputCondition, type InputLabelWhen, type InputParams, type InputSpanWhen } from "../Interfaces/FormInterfaces.ts";
+/** No value: null, undefined, an empty or blank text, an empty list. `false` and `0` are values. */
+export declare function isEmptyValue(value: unknown): boolean;
+/**
+ * Whether one condition holds for the other input's value. A list value (a multiple choice) holds `in` when any of its
+ * items is listed, and `notIn` when none is. Every key the condition has must hold; one with none holds always.
+ */
+export declare function conditionHolds(condition: InputCondition, value: unknown): boolean;
+/** The conditions of a `showWhen` or a `readOnlyWhen`, as a list. */
+export declare function conditionsOf(conditions: InputParams["showWhen"]): readonly InputCondition[];
+/** Whether every condition holds, reading the other inputs' values with `read`. None holds always. */
+export declare function conditionsHold(conditions: InputParams["showWhen"], read: (name: string) => unknown): boolean;
+/** Whether an input with this `showWhen` shows, reading the other inputs' values with `read`: every condition must hold. */
+export declare function inputShown(showWhen: InputParams["showWhen"], read: (name: string) => unknown): boolean;
+/** Whether an input with this `readOnlyWhen` is read-only, reading the other inputs' values with `read`: every condition must hold. */
+export declare function inputReadOnly(readOnlyWhen: InputParams["readOnlyWhen"], read: (name: string) => unknown): boolean;
+/** The text of `texts` for the other input's value (compared as text), or undefined when none is listed for it. */
+export declare function textFor(texts: Readonly<Record<string, string>> | undefined, value: unknown): string | undefined;
+/** The label an input with this `labelWhen` shows for the other input's value: listed, else `otherwise`, else its own. */
+export declare function labelFor(labelWhen: InputLabelWhen, value: unknown, own: InputParams["label"]): InputParams["label"];
+/**
+ * The columns an input with this `spanWhen` spans, reading the other inputs' values with `read`: `spanWhen.span` while
+ * every condition of `when` holds, else its own `span` (none: undefined, the whole row).
+ */
+export declare function spanFor(spanWhen: InputSpanWhen | undefined, read: (name: string) => unknown, own: InputParams["span"]): InputParams["span"];
+/**
+ * The inputs with a live `hidden` for each one that has `showWhen`, a live `readOnly` for each one that has
+ * `readOnlyWhen` - its own `hidden` / `readOnly` (a value or a getter), or else the conditions, read through `read` as
+ * the values are now - a live `label` (and `placeholder`) for each one that has `labelWhen`, and a live `span` for each
+ * one that has `spanWhen` (its own `span`, a value or a getter, while the conditions do not hold); and its `dependsOn`
+ * joined by the names they read (and by the inputs a `compute` is worked out from), so the form draws it again (and asks
+ * its rule again) when they change. The other params are copied with their getters as they are. The same array when no
+ * input has any.
+ *
+ * @example withInputConditions(inputs, name => store.get(name))
+ */
+export declare function withInputConditions(inputs: readonly InputParams[], read: (name: string) => unknown): readonly InputParams[];
+/**
+ * The inputs with each worked-out one's `dependsOn` joined by the inputs it is worked out from (`compute.from`), so what
+ * follows `dependsOn` - a row's cells (`RowsStore`), as a form's do through `withInputConditions` - draws it again when
+ * one of them changes. The same array when none is worked out from another, and the same copy for the same array.
+ */
+export declare function withComputeSources(inputs: readonly InputParams[]): readonly InputParams[];
+/** Whether the input is worked out from others (`compute`): it holds no value of the form's and is never typed in. */
+export declare function isComputedInput(params: InputParams | undefined): boolean;
+/**
+ * What a worked-out input (`compute`) shows for these values and the form's `computeWith`. A page's rule that throws
+ * shows nothing, and says so in the console, so one bad figure never takes the form down with it.
+ */
+export declare function computedValue(params: InputParams, values: FormValues, withValue: unknown): unknown;
+/**
+ * A worked-out value as its box writes it: a Number input's figure with its `decimals` always written (1,073.50), grouped,
+ * in `locale` (the person's, unless the params name their own); any other input's value as text. Null, undefined, "",
+ * NaN, or a figure that is not finite, write nothing, so the box is blank rather than "NaN" or "0.00".
+ */
+export declare function computedText(params: InputParams, value: unknown, locale?: string): string;