@fieldia/core 0.27.0 → 0.28.0

package/src/lib/record/form.mjs

@@ -85,7 +85,9 @@ function innerForm(options, within, place, outer) {
     const page = zonedPage(options.page);
     const scheduler = options.scheduler ?? hostScheduler;
     // A field's label small inside a message's sentence where the page asks (`lowerLabels`).
-    const messages = page.lowerLabels ? { ...(options.messages ?? MESSAGES.en), lowerLabels: true } : (options.messages ?? MESSAGES.en);
+    // …and a day written in the page's order where it says one (`look.dateOrder`): "can't be after Oct 20, 2026".
+    const dateOrder = page.look?.dateOrder;
+    const messages = page.lowerLabels || dateOrder ? { ...(options.messages ?? MESSAGES.en), lowerLabels: page.lowerLabels, dateOrder } : (options.messages ?? MESSAGES.en);
     /** One of the form's sentences in the words the page names its records by (`records`), else as the language says it plainly. */
     const named = (noun, plain) => recordSentence(page.records, noun, plain, messages.locale);
     /** The app's functions the page's expressions call: a name none may call is refused now. */
@@ -550,6 +552,7 @@ function innerForm(options, within, place, outer) {
     let edit = false;
     function set(patch) {
         const was = state.values;
+        const choicesWas = state.choices;
         const shown = state.errors;
         const edited = edit;
         edit = false;
@@ -558,6 +561,12 @@ function innerForm(options, within, place, outer) {
         // A line's choices go with their line.
         if (state.values !== was)
             state = { ...state, choices: choicesNow(state.choices) };
+        // What was said taken out is said while it is true: an option offered again, or picked again, is said no more.
+        if ((state.values !== was || state.choices !== choicesWas) && Object.keys(state.takenOut).length) {
+            const takenOut = takenOutTrue();
+            if (takenOut !== state.takenOut)
+                state = { ...state, takenOut };
+        }
         // What waits for an app's answer, as the values shown last settled.
         if (patch.values !== undefined && patch.asked === undefined && !sameAsked(state.asked, askedNow))
             state = { ...state, asked: Object.fromEntries(askedNow) };
@@ -858,7 +867,9 @@ function innerForm(options, within, place, outer) {
         const written = line
             ? (values[field] ?? []).map((l) => (l.key === line.key ? { ...l, values: { ...l.values, [line.column]: without(l.values[line.column]) } } : l))
             : without(values[field]);
-        writeValues({ ...values, [field]: written }, {}, false, { [line ? `${field}.${line.key}.${line.column}` : field]: takenOutWords(labels) });
+        const path = line ? `${field}.${line.key}.${line.column}` : field;
+        takenOutOf.set(path, lost.map((value, i) => ({ value, label: labels[i] })));
+        writeValues({ ...values, [field]: written }, {}, false, { [path]: takenOutWords(labels) });
         afterEdit(field);
         changed(field, 'step', { keep: true });
     }
@@ -967,6 +978,38 @@ function innerForm(options, within, place, outer) {
      * "Garden is no longer offered, so it was taken out".
      */
     const takenOutWords = (labels) => fillMessage(messages, labels.length > 1 ? messages.notOfferedNowMany : messages.notOfferedNow, { name: listedLabels(labels.map((label) => (label.includes('{') ? wordsNow(label) : label))) });
+    /** The options each note of `takenOut` names, by its path: a note goes once none of them is still out. */
+    const takenOutOf = new Map();
+    /**
+     * The notes of options taken out (`FormState.takenOut`) that are still true for the values and the choices now: one
+     * whose options are all offered again — the type that offers them picked again, the treatment ticked again above, the
+     * app's list asked again offering it — or picked again goes; one with some still out names those. A list being asked
+     * again says nothing yet. The same notes, when none changed.
+     */
+    function takenOutTrue() {
+        let kept = null;
+        for (const path of Object.keys(state.takenOut)) {
+            const options = takenOutOf.get(path);
+            const held = valueAt(state.values, path);
+            if (!options || held === gone || state.choices[path]?.loading)
+                continue;
+            const offered = form.offered(path);
+            if (!offered)
+                continue;
+            const chosen = [held].flat();
+            const left = options.filter((option) => !chosen.includes(option.value) && !offered.some((one) => one.value === option.value));
+            if (left.length === options.length)
+                continue;
+            kept ??= { ...state.takenOut };
+            if (left.length) {
+                takenOutOf.set(path, left);
+                kept[path] = takenOutWords(left.map((option) => option.label));
+            }
+            else
+                delete kept[path];
+        }
+        return kept ?? state.takenOut;
+    }
     /** A line's field as its value is checked: its choices from the app's list, those loaded for its line. */
     function checkedLine(path, def) {
         const loaded = def.type === 'selection' && optionsList(def.optionsFrom) ? state.choices[path]?.options : null;
@@ -1152,6 +1195,23 @@ function innerForm(options, within, place, outer) {
         const name = node.field;
         return unticked(node) ?? checkInput(page.fields[name], node.source, state.values[name], messages) ?? checkValue(checked(name), state.values[name], nodeState(node.id).required, messages, today(), node.source.widget) ?? ruleCheck(node).error;
     }
+    /** What a check would refuse now (`collectErrors`), for the state it was found for. */
+    let refusals = null;
+    /**
+     * Whether the form refuses the answer at a path — a field's, or a table line's cell (`field.lineKey.subfield`) — as a
+     * check would now: one it shows that holds a value its rules do not take (under its least, past today, a pattern not
+     * met, an answer rule's error). An empty answer is none, required or not: there is nothing worked out from it to wait.
+     */
+    function refusedAt(path) {
+        if (refusals?.state !== state)
+            refusals = { state, errors: collectErrors() };
+        if (!refusals.errors[path])
+            return false;
+        const parts = path.split('.');
+        const def = page.fields[parts[0]];
+        const held = valueAt(state.values, path);
+        return held !== gone && !isEmpty((parts.length > 2 && def?.type === 'one2many' ? def.fields[parts[parts.length - 1]] : def), held);
+    }
     /** Warnings for the visible fields of the page, without publishing them. */
     function collectWarnings() {
         const warnings = {};
@@ -1420,6 +1480,8 @@ function innerForm(options, within, place, outer) {
         if (out) {
             settled = out.values;
             takenOut = { ...takenOut, ...out.said };
+            for (const [path, gone] of Object.entries(out.gone))
+                takenOutOf.set(path, gone);
         }
         if (Object.keys(takenOut).length || Object.keys(state.takenOut).length)
             extra = { takenOut, ...extra };
@@ -2707,11 +2769,13 @@ function innerForm(options, within, place, outer) {
             return changesOptions(cell ? (lines?.type === 'one2many' ? lines.fields[cell.column] : undefined) : page.fields[name]);
         },
         waitsFor(name) {
-            const found = state.asked[name];
-            if (found)
-                return { field: name, asking: true, ...(found.failed !== undefined ? { failed: found.failed } : {}) };
+            // What it is worked out from first: an answer that does not read, or that the form refuses, is never asked about.
             const from = workedOut.get(name);
-            return from ? waitingOn(page, from, state.values, state.unread) : null;
+            const waits = from ? waitingOn(page, from, state.values, state.unread, refusedAt) : null;
+            if (waits)
+                return waits;
+            const found = state.asked[name];
+            return found ? { field: name, asking: true, ...(found.failed !== undefined ? { failed: found.failed } : {}) } : null;
         },
         problem(name) {
             fieldDef(name);