nexus-shared 1.1.20 → 2.0.0

package/dist/Helpers/FormStore.js

@@ -0,0 +1,734 @@
+import { deleteFormDraft, readFormDraft, writeFormDraft } from "./FormDrafts.js";
+import { initialInputValue, inputValuesEqual, isRowsInput, normalizeInputValue, validateInput } from "./InputParamsHelpers.js";
+const INITIAL_STATUS = {
+    changed: false,
+    submitting: false,
+    loading: false,
+    showAll: false,
+    problems: [],
+    message: null,
+    savedAt: null,
+    draftSavedAt: null,
+    restored: null,
+    formId: null,
+    buttons: 0,
+};
+/** How long values rest before a draft is written, in milliseconds. */
+const DRAFT_DELAY = 600;
+/** Equal plain data, however deep: what a draft or a reload compares, where arrays and objects are new copies. */
+function sameData(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => sameData(item, b[index]));
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every(key => sameData(a[key], b[key]));
+}
+function sameList(a, b) {
+    return a.length === b.length && a.every((item, index) => item === b[index]);
+}
+export class FormStore {
+    options = { inputs: [] };
+    inputByName = new Map();
+    values = {};
+    initial = {};
+    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();
+    /** Rows inputs are checked when asked: 10,000 rows on every keystroke would be slow, and the rows check themselves. */
+    staleRules = new Set();
+    crossErrors = new Map();
+    crossMessage = null;
+    serverErrors = new Map();
+    serverMessage = null;
+    forced = new Set();
+    touched = new Set();
+    showAll = false;
+    /** Inputs the page found problems in on the last submit. */
+    attention = [];
+    changedNames = new Set();
+    // Rendering: a revision per value set from code (its input mounts again with it), a generation for every input.
+    revisions = new Map();
+    generation = 0;
+    versions = new Map();
+    fieldListeners = new Map();
+    statusListeners = new Set();
+    // Kept without the values' type, so a store of any values passes where a store of plain values is asked for.
+    valueListeners = new Set();
+    status = INITIAL_STATUS;
+    draftTimer;
+    /** The draft key already looked up. Drafts are written only after, so an old draft is never overwritten unread. */
+    draftChecked = null;
+    draftSeq = 0;
+    /** The user cancelled: no draft is written until they change a value again. */
+    draftDropped = false;
+    /** A load during a render tells nobody; `announce` does, once the form has mounted. */
+    quiet = false;
+    unannounced = false;
+    /** The form on the page. Set by `Form`. */
+    view = null;
+    /** Submits the `<form>`, as its Save button does. Set by `SubmitForm`. */
+    submitter = null;
+    /* Reading */
+    /** Whether the form has loaded its first values. */
+    get started() {
+        return this.isStarted;
+    }
+    get inputs() {
+        return this.options.inputs;
+    }
+    /** Every value, plus the fields the record came with. The same object until something changes; do not change it. */
+    getValue() {
+        return this.values;
+    }
+    get(name) {
+        return this.values[name];
+    }
+    /** The values the form opened with, or saved last. */
+    getInitial() {
+        return this.initial;
+    }
+    /** Only the values that differ from the ones the form opened with or saved last. */
+    getChanges() {
+        const changes = {};
+        for (const name of this.changedInputs())
+            changes[name] = this.values[name];
+        return changes;
+    }
+    /** The inputs whose values changed, in form order. */
+    changedInputs() {
+        return this.options.inputs.filter(params => this.changedNames.has(params.name)).map(params => params.name);
+    }
+    isChanged() {
+        return this.changedNames.size > 0;
+    }
+    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) {
+        return this.shownWith(name, this.crossErrors);
+    }
+    /** The shown message, with the form's rule messages given, such as the ones before a change. */
+    shownWith(name, crossErrors) {
+        const server = this.serverErrors.get(name);
+        if (server)
+            return server;
+        const cross = crossErrors.get(name);
+        if (cross && (this.showAll || this.touched.has(name)))
+            return cross;
+        if (this.forced.has(name))
+            return this.ruleError(name) ?? undefined;
+        return 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;
+            if (message)
+                this.ruleErrors.set(name, message);
+            else
+                this.ruleErrors.delete(name);
+        }
+        return this.ruleErrors.get(name) ?? null;
+    }
+    /** The form's own rule message for an input, whether it shows or not. */
+    formRuleError(name) {
+        return this.crossErrors.get(name) ?? null;
+    }
+    /** The form's own rule message about the whole form. */
+    get formRuleMessage() {
+        return this.crossMessage;
+    }
+    /** 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);
+    }
+    /** Whether every value passes, as far as the values tell. `validate()` also asks the inputs on the page. */
+    isValid() {
+        return this.problems().length === 0 && !this.crossMessage;
+    }
+    /** Changes whenever the input must render again: a new value from code, or a message it shows. */
+    fieldVersion(name) {
+        return this.versions.get(name) ?? 0;
+    }
+    /** The input's render stamp: it mounts again when this changes, to show a value that did not come from typing. */
+    stamp(name) {
+        return `${this.generation}.${this.revisions.get(name) ?? 0}`;
+    }
+    /* Subscribing */
+    subscribeField(name, listener) {
+        let set = this.fieldListeners.get(name);
+        if (!set)
+            this.fieldListeners.set(name, (set = new Set()));
+        set.add(listener);
+        return () => {
+            set.delete(listener);
+            if (!set.size && this.fieldListeners.get(name) === set)
+                this.fieldListeners.delete(name);
+        };
+    }
+    subscribeStatus = (listener) => {
+        this.statusListeners.add(listener);
+        return () => this.statusListeners.delete(listener);
+    };
+    /** Every value after each change. `name` is the input the user changed, or `null` for a load, a reset, or several at once. */
+    subscribeValue = (listener) => {
+        const stored = listener;
+        this.valueListeners.add(stored);
+        return () => this.valueListeners.delete(stored);
+    };
+    /* Changing */
+    /**
+     * New inputs or rules. `recheck` checks every value again (the form does after a change of inputs or settings);
+     * without it, only the callbacks are swapped, which a parent's render does every time.
+     */
+    configure(options, recheck = true) {
+        const previous = this.options;
+        const draftMoved = options.draftKey !== previous.draftKey;
+        this.options = options;
+        if (recheck) {
+            const shown = this.shownSnapshot();
+            this.indexInputs();
+            if (this.isStarted)
+                this.adoptNewInputs(previous.inputs);
+            this.checkAllRules();
+            this.checkCross();
+            this.bumpShownChanges(shown);
+            this.patchStatus({ message: this.formMessage() });
+        }
+        if (draftMoved && this.isStarted) {
+            clearTimeout(this.draftTimer);
+            this.draftChecked = null;
+            if (options.draftKey)
+                void this.restoreDraft();
+        }
+    }
+    /**
+     * Loads values, such as a record from a server. They become the values the form compares with, and every input shows
+     * them. With `keepChanged`, the values the user changed stay (a refresh that merges): only the others change, and the
+     * names returned are the changed values whose loaded ones also changed, so the page can say so. `draft: false` leaves
+     * a saved draft for a later load (the form's placeholders show while the real values load). `quiet` tells no listener
+     * until `announce()`, for a load during a render.
+     */
+    load(values = {}, { keepChanged = false, draft = true, quiet = false } = {}) {
+        this.quiet = quiet;
+        this.unannounced ||= quiet;
+        try {
+            return this.loadValues(values, keepChanged, draft);
+        }
+        finally {
+            this.quiet = false;
+        }
+    }
+    /** Tells listeners about a quiet load. */
+    announce() {
+        if (!this.unannounced)
+            return;
+        this.unannounced = false;
+        for (const listener of [...this.statusListeners])
+            listener();
+        this.emit(null);
+    }
+    loadValues(values, keepChanged, draft) {
+        if (!this.inputByName.size && this.options.inputs.length)
+            this.indexInputs();
+        const next = this.normalize(values);
+        const merge = keepChanged && this.isStarted;
+        const conflicts = [];
+        let current = next;
+        if (merge) {
+            current = { ...next };
+            for (const name of this.changedInputs()) {
+                if (!sameData(next[name], this.initial[name]))
+                    conflicts.push(name);
+                current[name] = this.values[name];
+            }
+        }
+        const previous = this.values;
+        this.initial = next;
+        this.values = current;
+        this.changedNames = new Set(merge ? [...this.changedNames].filter(name => !inputValuesEqual(current[name], next[name])) : []);
+        if (merge) {
+            // Only inputs whose value changed mount again, so an input being typed in keeps its focus.
+            for (const params of this.options.inputs)
+                if (!inputValuesEqual(previous[params.name], current[params.name]))
+                    this.nextRevision(params.name);
+        }
+        else {
+            this.generation++;
+            this.touched.clear();
+        }
+        this.serverErrors.clear();
+        this.serverMessage = null;
+        this.forced.clear();
+        this.showAll = false;
+        this.attention = [];
+        this.draftDropped = false;
+        this.checkAllRules();
+        this.checkCross();
+        this.isStarted = true;
+        this.bumpAll();
+        this.patchStatus({
+            changed: this.changedNames.size > 0,
+            showAll: false,
+            problems: [],
+            message: null,
+            savedAt: null,
+            restored: merge ? this.status.restored : null,
+        });
+        this.emit(null);
+        const { draftKey } = this.options;
+        if (draft && draftKey && this.draftChecked !== draftKey)
+            void this.restoreDraft();
+        else
+            this.scheduleDraft();
+        return conflicts;
+    }
+    /** Brings back the values the form opened with or saved last, and clears every message. The draft goes too. */
+    reset() {
+        this.values = { ...this.initial };
+        this.changedNames.clear();
+        this.generation++;
+        this.clearMessages();
+        this.checkAllRules();
+        this.checkCross();
+        this.bumpAll();
+        this.patchStatus({ changed: false, showAll: false, problems: [], message: null, restored: null });
+        this.emit(null);
+        this.flushDraft();
+    }
+    /** Sets a value from code. Its input shows it at once, and it counts as a change. */
+    set(name, value) {
+        this.change([[name, value]], "code");
+    }
+    /** Sets several values from code, as one change. */
+    setValues(values) {
+        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.
+     */
+    input(name, value, stamp) {
+        if (stamp !== this.stamp(name))
+            return;
+        this.change([[name, value]], "input");
+    }
+    /** Marks an input as left by the user: the form's rule messages on it show from now on. */
+    touch(name) {
+        if (this.touched.has(name))
+            return;
+        const before = this.shownError(name);
+        this.touched.add(name);
+        if (this.shownError(name) !== before)
+            this.bump(name);
+    }
+    /**
+     * Shows messages from outside, such as a server's, on their inputs, with a message for the whole form. They replace
+     * the ones shown before; an input's message clears once its value changes. Names that are not inputs join the form's message.
+     */
+    setErrors(errors = {}, message) {
+        const shown = this.shownSnapshot();
+        const others = [];
+        this.serverErrors.clear();
+        for (const [name, text] of Object.entries(errors)) {
+            if (!text)
+                continue;
+            const params = this.inputByName.get(name);
+            if (params && !params.hidden)
+                this.serverErrors.set(name, text);
+            else
+                others.push(text);
+        }
+        this.serverMessage = [message, ...others].filter(Boolean).join(" ") || null;
+        this.bumpShownChanges(shown);
+        this.patchStatus({ message: this.formMessage(), problems: this.problemList() });
+    }
+    /** Clears the messages set with `setErrors`. */
+    clearErrors() {
+        this.setErrors({}, null);
+    }
+    /* The page */
+    /** Checks every value as a submit does: every message shows, and the first problem takes focus. Returns whether all is valid. */
+    validate() {
+        const problems = this.view ? this.view.validate() : this.reveal(this.problems());
+        return problems.length === 0 && !this.crossMessage;
+    }
+    /** Focuses an input by name, or the form's first input. */
+    focus(name) {
+        this.view?.focus(name);
+    }
+    /** Submits the form as its Save button does. Only a `SubmitForm` or an `ApiForm` can. */
+    submit() {
+        this.submitter?.();
+    }
+    /* Drafts */
+    /** Writes the draft now, e.g. when the page is hidden. With nothing changed, the draft is removed. */
+    flushDraft() {
+        clearTimeout(this.draftTimer);
+        this.draftTimer = undefined;
+        const key = this.options.draftKey;
+        if (!key || this.draftChecked !== key || this.draftDropped)
+            return;
+        const seq = ++this.draftSeq;
+        if (!this.changedNames.size) {
+            void deleteFormDraft(key);
+            this.patchStatus({ draftSavedAt: null });
+            return;
+        }
+        const values = {};
+        const base = {};
+        for (const name of this.changedNames) {
+            values[name] = this.values[name];
+            base[name] = this.initial[name];
+        }
+        const savedAt = Date.now();
+        void writeFormDraft(key, { values, base, savedAt }).then(stored => {
+            if (stored && seq === this.draftSeq && key === this.options.draftKey && this.changedNames.size)
+                this.patchStatus({ draftSavedAt: savedAt });
+        });
+    }
+    /** Puts back the values of the draft brought back when the form opened, and removes the draft. */
+    discardDraft() {
+        const restored = this.status.restored;
+        this.patchStatus({ restored: null });
+        if (restored)
+            this.change(restored.names.map(name => [name, this.initial[name]]), "code");
+        this.flushDraft();
+    }
+    /** Hides the notice of a restored draft and keeps its values. */
+    dismissDraft() {
+        this.patchStatus({ restored: null });
+    }
+    /** Removes the draft and leaves the values as they are, e.g. when the user cancels. Drafts start again with the next change. */
+    dropDraft() {
+        clearTimeout(this.draftTimer);
+        this.draftSeq++;
+        this.draftDropped = true;
+        const key = this.options.draftKey;
+        if (key)
+            void deleteFormDraft(key);
+        this.patchStatus({ draftSavedAt: null, restored: null });
+    }
+    /* For the form's components */
+    /** @internal Shows every message, as a submit does. `forced` are inputs whose own messages missed a problem their values have. */
+    reveal(problems, forced = []) {
+        const shown = this.shownSnapshot();
+        this.showAll = true;
+        for (const name of forced)
+            this.forced.add(name);
+        this.attention = problems;
+        this.bumpShownChanges(shown);
+        this.patchStatus({ showAll: true, problems: this.problemList(), message: this.formMessage() });
+        return problems;
+    }
+    /** @internal The inputs the page finds problems in, as values change after a submit. */
+    setAttention(names) {
+        if (sameList(names, this.attention))
+            return;
+        this.attention = names;
+        this.patchStatus({ problems: this.problemList() });
+    }
+    /** @internal A submit starts: messages from the last answer go. */
+    beginSubmit() {
+        const shown = this.shownSnapshot();
+        this.serverErrors.clear();
+        this.serverMessage = null;
+        this.bumpShownChanges(shown);
+        this.patchStatus({ submitting: true, message: this.formMessage(), problems: this.problemList() });
+    }
+    /** @internal A submit ended without a save. */
+    endSubmit() {
+        this.patchStatus({ submitting: false });
+    }
+    /**
+     * @internal A save: the values sent become the ones the form compares with; values typed while it ran stay changes.
+     * `extra` (from the server, such as a new id) is set on top.
+     */
+    commit(saved, extra) {
+        const shown = this.shownSnapshot();
+        this.initial = extra ? this.normalize({ ...saved, ...extra }) : saved;
+        if (extra) {
+            for (const [name, value] of Object.entries(extra)) {
+                const params = this.inputByName.get(name);
+                const next = params && !params.hidden ? normalizeInputValue(params, value) : value;
+                if (inputValuesEqual(this.values[name], next))
+                    continue;
+                this.values = { ...this.values, [name]: next };
+                if (params)
+                    this.nextRevision(name);
+                this.bump(name);
+            }
+        }
+        this.changedNames = new Set(this.options.inputs.filter(params => !inputValuesEqual(this.values[params.name], this.initial[params.name])).map(params => params.name));
+        this.clearMessages();
+        this.bumpShownChanges(shown);
+        this.patchStatus({ changed: this.changedNames.size > 0, submitting: false, showAll: false, problems: [], message: null, savedAt: Date.now(), restored: null });
+        if (extra)
+            this.emit(null);
+        this.flushDraft();
+    }
+    /** @internal A save after which the form went back to its opening values (`resetOnSuccess`). */
+    markSaved() {
+        this.patchStatus({ submitting: false, savedAt: Date.now() });
+    }
+    /** @internal */
+    setLoading(loading) {
+        this.patchStatus({ loading });
+    }
+    /** @internal */
+    setFormId(formId) {
+        this.patchStatus({ formId });
+    }
+    /** @internal A `FormButtons` shows the status; returns its removal. */
+    addButtons() {
+        this.patchStatus({ buttons: this.status.buttons + 1 });
+        return () => this.patchStatus({ buttons: Math.max(0, this.status.buttons - 1) });
+    }
+    /* Inside */
+    indexInputs() {
+        this.inputByName = new Map(this.options.inputs.map(params => [params.name, params]));
+    }
+    /** 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;
+            result[params.name] = params.name in values ? normalizeInputValue(params, values[params.name]) : initialInputValue(params);
+        }
+        return result;
+    }
+    /** 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))
+                continue;
+            const { name } = params;
+            const value = name in this.values ? normalizeInputValue(params, this.values[name]) : initialInputValue(params);
+            const initial = name in this.initial ? normalizeInputValue(params, this.initial[name]) : value;
+            this.values = { ...this.values, [name]: value };
+            this.initial = { ...this.initial, [name]: initial };
+            if (inputValuesEqual(value, initial))
+                this.changedNames.delete(name);
+            else
+                this.changedNames.add(name);
+        }
+    }
+    change(entries, source) {
+        const crossBefore = this.crossErrors;
+        const shown = new Map();
+        const remounted = new Set();
+        const written = [];
+        const remember = (name) => {
+            if (!shown.has(name))
+                shown.set(name, this.shownError(name));
+        };
+        const write = (name, value, from) => {
+            const params = this.inputByName.get(name);
+            const next = params && !params.hidden && from === "code" ? normalizeInputValue(params, value) : value;
+            if (inputValuesEqual(this.values[name], next))
+                return;
+            remember(name);
+            this.values = { ...this.values, [name]: next };
+            if (from === "code" && params) {
+                this.nextRevision(name);
+                remounted.add(name);
+            }
+            // A changed value is a new question: the server's answer and the form's shown rule message no longer apply.
+            this.serverErrors.delete(name);
+            this.forced.delete(name);
+            this.checkRule(name);
+            if (inputValuesEqual(next, this.initial[name]))
+                this.changedNames.delete(name);
+            else
+                this.changedNames.add(name);
+            written.push(name);
+        };
+        for (const [name, value] of entries)
+            write(name, value, source);
+        if (!written.length)
+            return;
+        // Values derived from the ones the user changed, such as an amount from a quantity and a rate.
+        const { onFieldChange } = this.options;
+        if (source === "input" && onFieldChange) {
+            for (const name of [...written]) {
+                const patch = onFieldChange(name, this.values[name], this.values);
+                if (patch)
+                    for (const [field, value] of Object.entries(patch))
+                        if (field !== name)
+                            write(field, value, "code");
+            }
+        }
+        // The form's rule runs again: an input it now names, or no longer names, shows the change even if nobody typed in it.
+        for (const name of this.checkCross())
+            if (!shown.has(name))
+                shown.set(name, this.shownWith(name, crossBefore));
+        for (const [name, before] of shown)
+            if (remounted.has(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);
+        // A change after a cancel is worth keeping again.
+        if (source === "input")
+            this.draftDropped = false;
+        this.scheduleDraft();
+    }
+    checkRule(name) {
+        const params = this.inputByName.get(name);
+        if (params && isRowsInput(params)) {
+            this.staleRules.add(name);
+            return;
+        }
+        this.staleRules.delete(name);
+        const message = params && !params.hidden && !this.options.locked ? validateInput(params, this.values[name], this.options.context) : null;
+        if (message)
+            this.ruleErrors.set(name, message);
+        else
+            this.ruleErrors.delete(name);
+    }
+    checkAllRules() {
+        this.ruleErrors.clear();
+        this.staleRules.clear();
+        for (const params of this.options.inputs)
+            this.checkRule(params.name);
+    }
+    /** Runs the form's own rule; returns the inputs whose message from it changed. */
+    checkCross() {
+        const result = this.options.locked ? null : this.options.validate?.(this.values);
+        const next = new Map();
+        const others = [];
+        if (typeof result === "string") {
+            if (result)
+                others.push(result);
+        }
+        else if (result && typeof result === "object") {
+            for (const [name, message] of Object.entries(result)) {
+                if (!message)
+                    continue;
+                const params = this.inputByName.get(name);
+                if (params && !params.hidden)
+                    next.set(name, message);
+                else
+                    others.push(message);
+            }
+        }
+        const changed = [];
+        for (const name of new Set([...this.crossErrors.keys(), ...next.keys()]))
+            if (this.crossErrors.get(name) !== next.get(name))
+                changed.push(name);
+        this.crossErrors = next;
+        this.crossMessage = others.length ? others.join(" ") : null;
+        return changed;
+    }
+    clearMessages() {
+        this.serverErrors.clear();
+        this.serverMessage = null;
+        this.forced.clear();
+        this.touched.clear();
+        this.showAll = false;
+        this.attention = [];
+    }
+    /** The form's message: a server's, or the form's own rule once a submit ran. */
+    formMessage() {
+        if (this.serverMessage)
+            return this.serverMessage;
+        return this.showAll ? this.crossMessage : null;
+    }
+    /** Inputs to point at: the ones the page found on the last submit, and those with a server's message, in form order. */
+    problemList() {
+        if (!this.attention.length && !this.serverErrors.size)
+            return this.status.problems.length ? [] : this.status.problems;
+        const names = this.options.inputs.filter(params => this.attention.includes(params.name) || this.serverErrors.has(params.name)).map(params => params.name);
+        return sameList(names, this.status.problems) ? this.status.problems : names;
+    }
+    nextRevision(name) {
+        this.revisions.set(name, (this.revisions.get(name) ?? 0) + 1);
+    }
+    bump(name) {
+        this.versions.set(name, (this.versions.get(name) ?? 0) + 1);
+        const listeners = this.fieldListeners.get(name);
+        if (listeners && !this.quiet)
+            for (const listener of [...listeners])
+                listener();
+    }
+    bumpAll() {
+        for (const params of this.options.inputs)
+            this.bump(params.name);
+    }
+    shownSnapshot() {
+        return new Map(this.options.inputs.map(params => [params.name, this.shownError(params.name)]));
+    }
+    bumpShownChanges(before) {
+        for (const params of this.options.inputs)
+            if (this.shownError(params.name) !== before.get(params.name))
+                this.bump(params.name);
+    }
+    patchStatus(patch) {
+        const current = this.status;
+        if (!Object.entries(patch).some(([key, value]) => !Object.is(value, current[key])))
+            return;
+        this.status = { ...this.status, ...patch };
+        if (!this.quiet)
+            for (const listener of [...this.statusListeners])
+                listener();
+    }
+    emit(name) {
+        if (this.quiet)
+            return;
+        for (const listener of [...this.valueListeners])
+            listener(this.values, name);
+    }
+    scheduleDraft() {
+        const key = this.options.draftKey;
+        if (!key || this.draftChecked !== key)
+            return;
+        clearTimeout(this.draftTimer);
+        this.draftTimer = setTimeout(() => this.flushDraft(), DRAFT_DELAY);
+    }
+    /** Looks for a draft under the form's key and brings back its values, except those the user changed since the form opened. */
+    async restoreDraft() {
+        const key = this.options.draftKey;
+        if (!key)
+            return;
+        const draft = await readFormDraft(key);
+        if (key !== this.options.draftKey || this.draftChecked === key)
+            return;
+        this.draftChecked = key;
+        if (!draft) {
+            this.scheduleDraft();
+            return;
+        }
+        const entries = [];
+        const conflicts = [];
+        for (const params of this.options.inputs) {
+            const { name } = params;
+            if (params.hidden || !(name in draft.values) || this.changedNames.has(name))
+                continue;
+            const value = draft.values[name];
+            if (sameData(value, this.values[name]))
+                continue;
+            if (name in draft.base && !sameData(draft.base[name], this.initial[name]))
+                conflicts.push(name);
+            entries.push([name, value]);
+        }
+        if (!entries.length) {
+            this.flushDraft();
+            return;
+        }
+        this.change(entries, "code");
+        this.patchStatus({ restored: { savedAt: draft.savedAt, names: entries.map(([name]) => name), conflicts }, draftSavedAt: draft.savedAt });
+    }
+}