@fieldia/designer 0.26.0 → 0.27.0

package/src/lib/designer.mjs

@@ -1,9 +1,9 @@
-import { validatePage, wideColumns, } from '@fieldia/core';
+import { functionTable, functionsPart, optionsField, optionsList, limitInstant, validatePage, wideColumns, } from '@fieldia/core';
 import { comparable, FIELD_NAME, FORMAT_VERSION, upgradePage } from '@fieldia/core';
 import { conditionToHide, conditionToHold, splitShownWhile, withShownWhile } from './conditions.mjs';
 import { findHeaderPart, headerCommands } from './header-commands.mjs';
 import { listCommands, setRowRules } from './list-commands.mjs';
-import { kindCommands } from './kind-commands.mjs';
+import { kindCommands, relabel } from './kind-commands.mjs';
 import { choiceCommands } from './choice-commands.mjs';
 import { inputCommands } from './input-commands.mjs';
 import { structureCommands } from './structure-commands.mjs';
@@ -25,6 +25,7 @@ import { rulesCommands } from './rules-commands.mjs';
 import { headCommands } from './head-commands.mjs';
 import { keepWhatRulesRead } from './rules-reads.mjs';
 import { stepsCommands } from './steps-commands.mjs';
+import { endingsCommands } from './endings-commands.mjs';
 import { forgetGoneTargets } from './steps-places.mjs';
 import { forgetGoneCounts } from './head-parts.mjs';
 import * as clipboard from './clipboard-ops.mjs';
@@ -153,6 +154,9 @@ export function createMemoryPageStore() {
 }
 const clone = (value) => JSON.parse(JSON.stringify(value));
 export function createDesigner(options) {
+    // The formula boxes work a formula out on made-up values with each of Fieldia's functions: their bodies beyond the
+    // plain ones are @fieldia/core's functions part, asked for at once.
+    functionsPart.load().catch(() => undefined);
     const store = options.store;
     /** How each editor reads a setting typed and not yet left (`settling`): publish runs them first. */
     const readers = new Set();
@@ -244,7 +248,10 @@ export function createDesigner(options) {
         })();
     }
     /** An edit's page checked as validatePage would, at the cost of what it changed. */
-    const checkEdit = editChecker();
+    // The app's functions: a name no page may call is refused now, as a form refuses it.
+    const functions = options.functions;
+    functionTable(functions);
+    const checkEdit = editChecker(functions);
     /**
      * Apply an edit to a copy, validate it, and keep it — or refuse it, saying
      * why. `after` runs once it is kept, before anyone is told: what the edit
@@ -354,6 +361,7 @@ export function createDesigner(options) {
     });
     const list = listCommands({
         apply,
+        functions,
         select(id) {
             selected = id;
             notify();
@@ -372,7 +380,8 @@ export function createDesigner(options) {
         ...choices,
         ...inputs,
         ...structures,
-        ...tableCommands({ apply }),
+        ...tableCommands({ apply, functions }),
+        ...endingsCommands({ apply }),
         words,
         locale,
         getPage: () => page,
@@ -1036,6 +1045,36 @@ export function createDesigner(options) {
                     delete draft.lowerLabels;
             }, 'lowerLabels');
         },
+        setPageLimits(patch) {
+            return apply((draft) => {
+                if (draft.data.kind !== 'responses')
+                    throw new Refusal((w) => w.refusals.limitsForResponses);
+                const limits = { ...(draft.limits ?? {}) };
+                for (const [key, value] of Object.entries(patch)) {
+                    if (value === null || value === undefined || value === false || (typeof value === 'string' && !value.trim()))
+                        delete limits[key];
+                    else
+                        limits[key] = value;
+                }
+                const opens = typeof limits['opens'] === 'string' ? limitInstant(limits['opens'], draft.timeZone) : null;
+                const closes = typeof limits['closes'] === 'string' ? limitInstant(limits['closes'], draft.timeZone, true) : null;
+                if (opens !== null && closes !== null && closes <= opens)
+                    throw new Refusal((w) => w.refusals.closesBeforeOpens);
+                // Its words alone say nothing of when: they go with the last of the rest.
+                if (Object.keys(limits).some((key) => key !== 'message'))
+                    draft.limits = limits;
+                else
+                    delete draft.limits;
+            }, `limits:${Object.keys(patch).join(',')}`);
+        },
+        setContinueLater(on) {
+            return apply((draft) => {
+                if (on)
+                    draft.continueLater = true;
+                else
+                    delete draft.continueLater;
+            }, 'continueLater');
+        },
         setDuplicates(patch) {
             return apply((draft) => {
                 if (patch.fields !== undefined && !patch.fields?.length)
@@ -1226,6 +1265,9 @@ export function createDesigner(options) {
                         fields[name] = { ...kept, label: column.label };
                     else if (column.kind === 'other')
                         throw new Refusal((w) => w.refusals.newColumnKind);
+                    // A new choice starts with one option, to be written over.
+                    else if (column.kind === 'choice')
+                        fields[name] = { type: 'selection', label: column.label, options: [{ value: 'option_1', label: words.defaults.option(1) }] };
                     else
                         fields[name] = { type: COLUMN_TYPES[column.kind], label: column.label };
                 }
@@ -1234,6 +1276,48 @@ export function createDesigner(options) {
             // Typing in a column's label is one undo step, as in an option.
             `columns:${id}:${columns.length}`);
         },
+        setColumnChoices(id, column, choices) {
+            return apply((draft) => {
+                const lines = fieldOfType(draft, id, ['one2many'], (w) => w.refusals.onlyLinesColumns, (w, label) => w.refusals.columnsFromModel(label));
+                const field = lines.fields[column];
+                if (field?.type !== 'selection')
+                    throw new Refusal((w) => w.refusals.notAChoiceColumn(field?.label ?? column));
+                if (choices.labels) {
+                    const options = relabel(field.options, choices.labels, 'option');
+                    if (!options.length && !field.optionsFrom)
+                        throw new Refusal((w) => w.refusals.columnNeedsOption(field.label));
+                    field.options = options;
+                }
+                if (choices.from === null) {
+                    delete field.optionsFrom;
+                    // Written again: one option to start from, when there were none.
+                    if (!field.options.length)
+                        field.options = [{ value: 'option_1', label: words.defaults.option(1) }];
+                }
+                else if (choices.from) {
+                    // What it changes with: the line's other columns, and the record's fields.
+                    const on = (choices.from.dependsOn ?? []).filter((name) => (name.startsWith('parent.') ? !!draft.fields[name.slice(7)] : name !== column && !!lines.fields[name]));
+                    field.optionsFrom = { list: choices.from.list, ...(on.length ? { dependsOn: on } : {}) };
+                }
+            }, 
+            // Typing an option's words, or a list's name, is one step.
+            choices.labels ? `column-options:${id}:${column}:${choices.labels.length}` : choices.from ? `column-list:${id}:${column}:${JSON.stringify(choices.from.dependsOn ?? [])}` : null);
+        },
+        setColumnOptionWhen(id, column, index, invisible) {
+            return apply((draft) => {
+                const lines = fieldOfType(draft, id, ['one2many'], (w) => w.refusals.onlyLinesColumns, (w, label) => w.refusals.columnsFromModel(label));
+                const field = lines.fields[column];
+                if (field?.type !== 'selection')
+                    throw new Refusal((w) => w.refusals.notAChoiceColumn(field?.label ?? column));
+                const option = field.options[index];
+                if (!option)
+                    throw new Refusal((w) => w.refusals.noOption(index + 1));
+                if (invisible === null || !invisible.trim())
+                    delete option.invisible;
+                else
+                    option.invisible = invisible.trim();
+            });
+        },
         undo() {
             const previous = past[past.length - 1];
             if (!previous)
@@ -1266,7 +1350,7 @@ export function createDesigner(options) {
             // A setting still typed is read first, as leaving its box reads it: what is published is what the boxes show.
             for (const read of [...readers])
                 read();
-            const checked = validatePage(page);
+            const checked = validatePage(page, { functions });
             if (!checked.ok)
                 throw new Error(words.refusals.cannotPublish);
             const version = store ? await store.publish(clone(page)) : versions.length + 1;
@@ -1276,7 +1360,7 @@ export function createDesigner(options) {
         },
         checks() {
             if (checksOf?.page !== page || checksOf.forms !== formsCame)
-                checksOf = { page, forms: formsCame, checks: pageChecks(page, { valid: checkEdit.passed(page), forms, words }) };
+                checksOf = { page, forms: formsCame, checks: pageChecks(page, { valid: checkEdit.passed(page), forms, words, functions }) };
             return [...checksOf.checks];
         },
         fixCheck: (check) => fixCheck(designer, check),
@@ -1299,13 +1383,15 @@ export function createDesigner(options) {
         // panel lane
         setEach: (ids, change) => apply((draft) => several.setEach(draft, ids, change, fromModel)),
         // json lane
-        ...pageJsonCommands({ getPage: () => page, apply, words }),
+        ...pageJsonCommands({ getPage: () => page, apply, words, functions }),
         lists: () => clone(options.lists ?? []),
+        functions: () => functions,
         setOptionsFrom(id, from) {
             const found = findNode(page, id);
-            const was = found?.node.type === 'field' ? page.fields[found.node.field]?.optionsFrom : undefined;
+            const was = optionsList(found?.node.type === 'field' ? page.fields[found.node.field]?.optionsFrom : undefined);
+            const list = optionsList(from ?? undefined);
             // Typing a list's name is one step, as typing a label is.
-            const naming = !!from && !!was && JSON.stringify(was.dependsOn ?? []) === JSON.stringify(from.dependsOn ?? []);
+            const naming = !!list && !!was && JSON.stringify(was.dependsOn ?? []) === JSON.stringify(list.dependsOn ?? []);
             return apply((draft) => {
                 const field = fieldOfType(draft, id, ['selection'], (w) => w.refusals.onlyChoiceFromList, (w, label) => w.refusals.choicesFromModel(label));
                 if (!from) {
@@ -1315,7 +1401,18 @@ export function createDesigner(options) {
                         field.options = [{ value: 'option_1', label: words.defaults.option(1) }];
                     return;
                 }
-                field.optionsFrom = { list: from.list, ...(from.dependsOn?.length ? { dependsOn: [...from.dependsOn] } : {}) };
+                const carried = optionsField(from);
+                if (carried) {
+                    const source = draft.fields[carried.field];
+                    if (carried.field === fieldNode(draft, id).field || source?.type !== 'selection')
+                        throw new Refusal((w) => w.refusals.carriedFromChoice);
+                    field.optionsFrom = { field: carried.field, ...(carried.picked === false ? { picked: false } : {}) };
+                    // Its own options follow those carried: none until some are written.
+                    field.options = field.options.filter((o) => !/^option_\d+$/.test(String(o.value)) || !isDefaultOption(o.label));
+                    return;
+                }
+                if (list)
+                    field.optionsFrom = { list: list.list, ...(list.dependsOn?.length ? { dependsOn: [...list.dependsOn] } : {}) };
             }, naming ? `list-name:${id}` : null);
         },
         // canvas lane
@@ -1353,11 +1450,11 @@ export function createDesigner(options) {
             const node = findNode(draft, id)?.node;
             if (!node || node.type !== 'related')
                 throw new Refusal((w) => w.layout.noPart(id));
-            changeRelated(draft, node, patch);
+            changeRelated(draft, node, patch, functions);
         }, `related:${id}:${Object.keys(patch).join(',')}`),
         setWidths: (widths, options) => apply((draft) => settings.setWidths(draft, widths, options?.twelfths)),
         // rules lane
-        ...rulesCommands({ apply, getPage: () => page, fromModel }),
+        ...rulesCommands({ apply, getPage: () => page, fromModel, functions }),
         // A record's head, and the parts it brought: a button's icon alone, toggle and menu; a tab's count; a field's access key.
         ...headCommands({ apply, select: (id) => designer.select(id), model, words }),
         // extend lane
@@ -1444,7 +1541,7 @@ export function createDesigner(options) {
         canOpenForm: () => typeof options.openForm === 'function',
         openForm: (id) => options.openForm?.(id),
         // steps lane
-        ...stepsCommands({ apply, getPage: () => page }),
+        ...stepsCommands({ apply, getPage: () => page, functions }),
     };
     return designer;
 }
@@ -1454,14 +1551,14 @@ createDesigner.open = async (id, store, options = {}) => {
     const page = draft ?? versions[versions.length - 1]?.page;
     if (!page)
         throw new Error(`The store has no page "${id}"`);
-    return createDesigner({ page, store, versions, model: options.model, lists: options.lists, kinds: options.kinds, looks: options.looks, openForm: options.openForm, locale: options.locale, regionSets: options.regionSets });
+    return createDesigner({ page, store, versions, model: options.model, lists: options.lists, functions: options.functions, kinds: options.kinds, looks: options.looks, openForm: options.openForm, locale: options.locale, regionSets: options.regionSets });
 };
 /** A sheet's status steps, by the id the designer picks them by: they show for some records only, and to some roles, as any part. */
 function statusbarOf(page, id) {
     return id === '#statusbar' && page.layout.type === 'sheet' ? page.layout.statusbar : undefined;
 }
 /** A related list changed as asked: names that are no field's refused, and what named a column taken away gone with it. */
-function changeRelated(draft, node, patch) {
+function changeRelated(draft, node, patch, functions) {
     const named = (name) => {
         if (!FIELD_NAME.test(name))
             throw new Refusal((w) => w.relatedPart.notAName(name));
@@ -1541,7 +1638,7 @@ function changeRelated(draft, node, patch) {
         node.card = JSON.parse(JSON.stringify(patch.card));
     }
     // Its rows' own rules, as a list's: each condition read on a row's record — its own fields, its id, the person.
-    setRowRules(node, patch, draft, { ...draft, fields: node.fields });
+    setRowRules(node, patch, draft, { ...draft, fields: node.fields }, functions);
     // A field taken away with its column goes from the card too: its lines, its title, picture and status.
     if (patch.columns !== undefined && node.card) {
         const card = node.card;