@fieldia/designer 0.24.0 → 0.26.0

package/src/lib/designer.d.ts

@@ -1,7 +1,7 @@
-import { type AnswerRule, type BotCheck, type ColumnCount, type ColumnsByWidth, type Field, type LabelPlace, type OptionsFrom, type PartLookKind, type HelpShown, type InputMode, type JsonValue, type MapFence, type MapLayer, type MapNode, type Page, type PageLook, type SetWhen } from '@fieldia/core';
+import { type AnswerRule, type BotCheck, type ColumnCount, type ColumnsByWidth, type Field, type LabelPlace, type OptionsFrom, type PartLookKind, type HelpShown, type InputMode, type JsonValue, type MapFence, type MapLayer, type MapNode, type LinkedField, type ListCard, type Page, type PageLook, type RelatedNode, type SetWhen } from '@fieldia/core';
 import { type Condition, type ShownWhile } from './conditions';
 import { type HeaderCommands } from './header-commands';
-import { type ListCommands } from './list-commands';
+import { type ListCommands, type RowRulesPatch } from './list-commands';
 import { type OptionDetails } from './kind-commands';
 import { type ChoiceCommands } from './choice-commands';
 import { type InputCommands } from './input-commands';
@@ -207,6 +207,8 @@ export interface Designer extends HeaderCommands, ListCommands, ChoiceCommands,
     } | null): boolean;
     /** The roles a part shows to (Flectra's groups=), `!` before one hiding it from people holding it; null shows it to everyone. */
     setRoles(id: string, roles: string[] | null): boolean;
+    /** Whether a field, a group, a tab or a related list prints with its record; false leaves it off paper (`"print": false`). */
+    setPrinted(id: string, printed: boolean): boolean;
     /** A part shown only while the record is edited, only while it is read, or always: Flectra's oe_edit_only and oe_read_only. */
     setShownWhile(id: string, mode: ShownWhile): boolean;
     /**
@@ -233,6 +235,33 @@ export interface Designer extends HeaderCommands, ListCommands, ChoiceCommands,
     }): boolean;
     /** A public page's bot check (`botCheck`): a hidden box, the fewest seconds, the slot its captcha is drawn in; null takes it off. A page of responses only. */
     setBotCheck(check: BotCheck | null): boolean;
+    /** What a printout of the page carries (`print`): its header and footer words, the app's logo by its address; empty or null takes one away. */
+    setPrint(patch: {
+        header?: string | null;
+        footer?: string | null;
+        logo?: string | null;
+    }): boolean;
+    /**
+     * A record page's possible duplicates (`duplicates`): the fields records like the one typed are found by — `null`
+     * or none takes the setting away — and when they are asked for, as typed (`type`, the default: `null`) or only as
+     * the record is saved (`save`).
+     */
+    setDuplicates(patch: {
+        fields?: string[] | null;
+        on?: 'type' | 'save' | null;
+    }): boolean;
+    /**
+     * What the page's records are called (`records`), so Fieldia's sentences name them: the words for one and for more
+     * — both, or neither (`null`, or both empty, takes the setting away) — and for one with its article (`a`, empty takes
+     * it away). Each kept as typed, its ends trimmed. Refused with only one of the two words.
+     */
+    setRecords(records: {
+        one: string;
+        other: string;
+        a?: string;
+    } | null): boolean;
+    /** A field's label written small inside Fieldia's sentences (`lowerLabels`), the page's own setting; false takes it away. */
+    setLowerLabels(on: boolean): boolean;
     /**
      * The page's phone numbers (`phone`): read the world over (`on`), or text boxes as typed (`on: false` takes the
      * setting away); the country a number typed without its + is read in, and whether a number shows abroad's way or at
@@ -386,6 +415,12 @@ export interface Designer extends HeaderCommands, ListCommands, ChoiceCommands,
         tools?: NonNullable<MapNode['tools']> | null;
         fences?: MapFence[] | null;
     }): boolean;
+    /**
+     * A related list's title, the model of its records and their link to this record, its columns (each a field of
+     * theirs, by name, with its definition: a column taken away takes its cells, order and search with it), its rows a
+     * page, New, and View all's page and where it opens; `null` takes the rows or View all away.
+     */
+    updateRelated(id: string, patch: RelatedPatch): boolean;
     /**
      * Several parts' widths as one edit: two trading width across the gutter
      * between them. With `twelfths`, widths are twelfths of their row, and a
@@ -542,3 +577,21 @@ export interface RegionSet {
     nameKey?: string;
     numbers?: readonly string[];
 }
+/** What a related list's panel changes (`updateRelated`). */
+export interface RelatedPatch extends RowRulesPatch {
+    title?: string;
+    model?: string;
+    field?: string;
+    /** Its columns, in order: each a field of its records, by name, with its definition. */
+    columns?: {
+        name: string;
+        field: LinkedField;
+    }[];
+    limit?: number | null;
+    create?: boolean;
+    /** Where a row's record and New's open: a dialog (the default, not written), or the app's own way. */
+    open?: NonNullable<RelatedNode['open']>;
+    viewAll?: NonNullable<RelatedNode['viewAll']> | null;
+    /** Its records as cards on a phone, as a list's: what a card shows ({} for the columns'); null for none. */
+    card?: ListCard | null;
+}

package/src/lib/designer.js

@@ -21,6 +21,7 @@ const ops = require("./layout-ops");
 const settings = require("./layout-settings");
 const twelfths = require("./layout-twelfths");
 const several = require("./layout-several");
+const print_setting_1 = require("./print-setting");
 const page_tree_1 = require("./page-tree");
 const layout_tree_1 = require("./layout-tree");
 const refusal_1 = require("./refusal");
@@ -31,6 +32,7 @@ const head_commands_1 = require("./head-commands");
 const rules_reads_1 = require("./rules-reads");
 const steps_commands_1 = require("./steps-commands");
 const steps_places_1 = require("./steps-places");
+const head_parts_1 = require("./head-parts");
 const clipboard = require("./clipboard-ops");
 const moves = require("./outline-moves");
 const outline_rows_1 = require("./outline-rows");
@@ -288,6 +290,10 @@ function createDesigner(options) {
         (0, rules_reads_1.keepWhatRulesRead)(page, draft);
         // steps lane: a tab or step taken away takes the steps that go to it, and its own, with it.
         (0, steps_places_1.forgetGoneTargets)(draft);
+        // A field taken away, or made a kind records are not compared by, is no longer one possible duplicates are found by.
+        forgetGoneDuplicates(draft);
+        // A related list taken out of a tab takes the tab's count of it with it.
+        (0, head_parts_1.forgetGoneCounts)(draft);
         const checked = checkEdit(page, draft);
         if (!checked.ok) {
             // A number setting the format refuses is said in its own words, in the designer's language: never a raw path.
@@ -913,6 +919,17 @@ function createDesigner(options) {
                     delete target.roles;
             });
         },
+        setPrinted(id, printed) {
+            return apply((draft) => {
+                const target = (0, print_setting_1.printablePart)(draft, id);
+                if (!target)
+                    throw new refusal_1.Refusal((w) => w.refusals.noElement(id));
+                if (printed)
+                    delete target.print;
+                else
+                    target.print = false;
+            });
+        },
         setRule(id, which, condition) {
             return apply((draft) => {
                 const found = (0, page_tree_1.findNode)(draft, id);
@@ -1001,6 +1018,61 @@ function createDesigner(options) {
                 }
             }, `page:${Object.keys(info).join(',')}`);
         },
+        setPrint(patch) {
+            return apply((draft) => {
+                const print = { ...draft.print };
+                for (const key of ['header', 'footer', 'logo']) {
+                    if (patch[key] === undefined)
+                        continue;
+                    const value = patch[key]?.trim() ?? '';
+                    if (!value)
+                        delete print[key];
+                    // An address an image is drawn from: never a script's, nor words.
+                    else if (key === 'logo' && !/^(https?:\/\/|data:image\/|\/|\.{0,2}\/?[^:\s]+$)/i.test(value))
+                        throw new refusal_1.Refusal((w) => w.refusals.logoAddress);
+                    else
+                        print[key] = key === 'logo' ? value : patch[key];
+                }
+                if (Object.keys(print).length)
+                    draft.print = print;
+                else
+                    delete draft.print;
+            }, `print:${Object.keys(patch).join(',')}`);
+        },
+        setRecords(records) {
+            return apply((draft) => {
+                const one = records?.one.trim() ?? '';
+                const other = records?.other.trim() ?? '';
+                // No words: the records unnamed, the labels small alone where asked.
+                if (!one && !other)
+                    return void delete draft.records;
+                if (!one || !other)
+                    throw new refusal_1.Refusal((w) => w.refusals.recordsBoth);
+                const a = records?.a?.trim();
+                draft.records = { one, other, ...(a ? { a } : {}) };
+            }, 'records');
+        },
+        setLowerLabels(on) {
+            return apply((draft) => {
+                if (on)
+                    draft.lowerLabels = true;
+                else
+                    delete draft.lowerLabels;
+            }, 'lowerLabels');
+        },
+        setDuplicates(patch) {
+            return apply((draft) => {
+                if (patch.fields !== undefined && !patch.fields?.length)
+                    return void delete draft.duplicates;
+                if (draft.data.kind !== 'record' || draft.layout.type === 'list')
+                    throw new refusal_1.Refusal((w) => w.refusals.duplicatesForRecords);
+                const fields = patch.fields ?? draft.duplicates?.fields ?? [];
+                if (!fields.length)
+                    return;
+                const on = patch.on === undefined ? draft.duplicates?.on : (patch.on ?? undefined);
+                draft.duplicates = { fields: [...new Set(fields)], ...(on === 'save' ? { on } : {}) };
+            }, null);
+        },
         setBotCheck(check) {
             return apply((draft) => {
                 if (!check)
@@ -1301,6 +1373,12 @@ function createDesigner(options) {
                     if (!draft.fields[name] && model[name])
                         draft.fields[name] = model[name];
         }, `map:${id}:${Object.keys(patch).join(',')}`),
+        updateRelated: (id, patch) => apply((draft) => {
+            const node = (0, page_tree_1.findNode)(draft, id)?.node;
+            if (!node || node.type !== 'related')
+                throw new refusal_1.Refusal((w) => w.layout.noPart(id));
+            changeRelated(draft, node, patch);
+        }, `related:${id}:${Object.keys(patch).join(',')}`),
         setWidths: (widths, options) => apply((draft) => settings.setWidths(draft, widths, options?.twelfths)),
         // rules lane
         ...(0, rules_commands_1.rulesCommands)({ apply, getPage: () => page, fromModel }),
@@ -1406,4 +1484,111 @@ createDesigner.open = async (id, store, options = {}) => {
 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) {
+    const named = (name) => {
+        if (!core_2.FIELD_NAME.test(name))
+            throw new refusal_1.Refusal((w) => w.relatedPart.notAName(name));
+    };
+    if (patch.title !== undefined) {
+        if (patch.title.trim())
+            node.title = patch.title;
+        else
+            delete node.title;
+    }
+    if (patch.model !== undefined) {
+        if (!patch.model.trim())
+            throw new refusal_1.Refusal((w) => w.relatedPart.noModel);
+        node.model = patch.model.trim();
+    }
+    if (patch.field !== undefined) {
+        named(patch.field);
+        node.field = patch.field;
+    }
+    if (patch.columns !== undefined) {
+        if (!patch.columns.length)
+            throw new refusal_1.Refusal((w) => w.relatedPart.lastColumn);
+        const names = patch.columns.map((column) => column.name);
+        names.forEach(named);
+        const twice = names.find((name, i) => names.indexOf(name) !== i);
+        if (twice)
+            throw new refusal_1.Refusal((w) => w.relatedPart.columnTwice(twice));
+        // Fields shown in no column stay (the link, an amount's currency); a column taken away goes, and what named it.
+        const fields = Object.fromEntries(Object.entries(node.fields).filter(([name]) => !node.columns.includes(name) || names.includes(name)));
+        for (const column of patch.columns)
+            fields[column.name] = JSON.parse(JSON.stringify(column.field));
+        node.fields = fields;
+        node.columns = names;
+        if (node.cells) {
+            for (const name of Object.keys(node.cells))
+                if (!names.includes(name))
+                    delete node.cells[name];
+            if (!Object.keys(node.cells).length)
+                delete node.cells;
+        }
+        if (node.sort) {
+            node.sort = node.sort.filter((order) => Object.prototype.hasOwnProperty.call(fields, order.field));
+            if (!node.sort.length)
+                delete node.sort;
+        }
+        if (node.searchFields) {
+            node.searchFields = node.searchFields.filter((name) => Object.prototype.hasOwnProperty.call(fields, name));
+            if (!node.searchFields.length)
+                delete node.searchFields;
+        }
+    }
+    if (patch.limit === null)
+        delete node.limit;
+    else if (patch.limit !== undefined)
+        node.limit = patch.limit;
+    if (patch.create === true)
+        delete node.create;
+    else if (patch.create === false)
+        node.create = false;
+    if (patch.open === 'app')
+        node.open = 'app';
+    else if (patch.open === 'dialog')
+        delete node.open;
+    if (patch.viewAll === null)
+        delete node.viewAll;
+    else if (patch.viewAll !== undefined)
+        node.viewAll = { page: patch.viewAll.page, ...(patch.viewAll.as && patch.viewAll.as !== 'dialog' ? { as: patch.viewAll.as } : {}) };
+    if (patch.card === null)
+        delete node.card;
+    else if (patch.card !== undefined) {
+        // Its card shows its own records' fields: one that is not theirs is refused, as a column's name is.
+        for (const name of (0, page_tree_1.listCardFields)(patch.card)) {
+            named(name);
+            if (!Object.prototype.hasOwnProperty.call(node.fields, name))
+                throw new refusal_1.Refusal((w) => w.relatedPart.notTheirs(name));
+        }
+        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.
+    (0, list_commands_1.setRowRules)(node, patch, draft, { ...draft, fields: node.fields });
+    // 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;
+        for (const key of ['title', 'subtitle', 'image', 'status'])
+            if (card[key] !== undefined && !Object.prototype.hasOwnProperty.call(node.fields, card[key]))
+                delete card[key];
+        if (card.fields) {
+            const kept = card.fields.filter((line) => (Array.isArray(line) ? line : [line]).every((part) => Object.prototype.hasOwnProperty.call(node.fields, typeof part === 'string' ? part : part.field)));
+            if (kept.length)
+                card.fields = kept;
+            else
+                delete card.fields;
+        }
+    }
+}
+/** The fields possible duplicates are found by (`duplicates`) that are still on the page and of a kind to compare: none left, the setting goes. */
+function forgetGoneDuplicates(page) {
+    if (!page.duplicates)
+        return;
+    const fields = page.duplicates.fields.filter((name) => (0, core_2.comparable)(page.fields[name]));
+    if (!fields.length)
+        delete page.duplicates;
+    else if (fields.length !== page.duplicates.fields.length)
+        page.duplicates = { ...page.duplicates, fields };
+}
 //# sourceMappingURL=designer.js.map