ngx-t-forms-types 0.0.30 → 0.0.34

package/dist/skillet/tests/variant-assembly.spec.js

@@ -0,0 +1,643 @@
+import { s } from '@hashbrownai/core';
+import { FormInputKeys } from '../../interfaces/FormBuilder/FormInputKeys.js';
+import { ElementTypes } from '../../interfaces/formInput/index.js';
+import { extraInputMemberSchemas } from '../extra-members.js';
+import { validateFormColumnInputs } from '../../schemas/FormInputSchema.js';
+import { validateForm } from '../../schemas/FormSchema.js';
+import { createFormDraftSchema } from '../form.js';
+import { COMMON_ELEMENTS, JOI_MANDATORY_COLUMN_KEYS, JOI_UNKNOWN_COLUMN_KEYS, UNRESOLVED_VARIANT_KEYS, createColumnSchema, } from '../variants.js';
+function columnJson(options = {}) {
+    return s.toJsonSchema(createColumnSchema(options));
+}
+/**
+ * Resolves a `$ref` against the schema's `$defs`.
+ *
+ * Skillet hoists any node instance it sees more than once, and the member
+ * registries exist precisely so that a property is ONE node reused everywhere —
+ * so most interesting members arrive as references rather than inline. A test
+ * that reads them without resolving is testing the reference, not the schema.
+ */
+function deref(json, node) {
+    const ref = node?.$ref;
+    if (!ref)
+        return node;
+    return json.$defs?.[ref.replace('#/$defs/', '')];
+}
+/**
+ * Every branch of the column union, grouped by the element it discriminates on.
+ *
+ * Grouped rather than keyed one-to-one because an element may contribute more
+ * than one branch — see the calculated-field split.
+ */
+function branches(options = {}) {
+    const json = columnJson(options);
+    const grouped = {};
+    for (const branch of json.anyOf) {
+        const element = branch.properties?.element?.const;
+        if (!element)
+            throw new Error('a column branch has no element discriminator');
+        (grouped[element] ??= []).push(branch);
+    }
+    return grouped;
+}
+/** The single branch for an element that contributes exactly one. */
+function only(grouped, element) {
+    const found = grouped[element];
+    if (found?.length !== 1) {
+        throw new Error(`expected exactly one ${element} branch, got ${found?.length}`);
+    }
+    return found[0];
+}
+const WORKFLOWS = [{ id: 'wf-1', name: 'Purchase requisition' }];
+describe('variant assembly', () => {
+    it('resolves every property listed by DefaultInputConfig', () => {
+        // A key that resolves to no node and is not a declared omission would be
+        // silently missing from every generated form of that element.
+        createColumnSchema({ workflows: WORKFLOWS });
+        expect([...new Set(UNRESOLVED_VARIANT_KEYS)]).toEqual([]);
+    });
+    it('builds a variant for every element it can complete', () => {
+        // `workflowDocumentPicker` REQUIRES `workflowPickerConfig`, which cannot be
+        // built without a workflow to point at. Offering it anyway would emit a
+        // picker missing its only required member, so the element is withdrawn
+        // instead — and comes back the moment a workflow is supplied.
+        const withoutWorkflows = Object.keys(branches());
+        expect(withoutWorkflows).not.toContain(ElementTypes.WorkflowDocumentPicker);
+        const withWorkflows = Object.keys(branches({ workflows: WORKFLOWS }));
+        expect(withWorkflows.sort()).toEqual([...Object.values(ElementTypes)].sort());
+    });
+    it('gives every variant the keys Joi requires of a column', () => {
+        const all = branches({ workflows: WORKFLOWS });
+        for (const [element, elementBranches] of Object.entries(all)) {
+            // validateForm() strips section titles before validating, so Joi never
+            // sees one and the mandatory base does not apply.
+            if (element === ElementTypes.SectionTitle)
+                continue;
+            for (const branch of elementBranches) {
+                for (const key of JOI_MANDATORY_COLUMN_KEYS) {
+                    expect(Object.keys(branch.properties))
+                        .withContext(`${element} is missing Joi-required '${key}'`)
+                        .toContain(key);
+                }
+            }
+        }
+    });
+    it('keeps element-specific properties out of other elements', () => {
+        const all = branches({ workflows: WORKFLOWS });
+        // The reason for discriminating at all. A flat schema would offer all of
+        // these on every element and the model would scatter them.
+        expect(Object.keys(only(all, ElementTypes.Toggle).properties)).not.toContain('fileType');
+        expect(Object.keys(only(all, ElementTypes.FileUpload).properties)).not.toContain('trueLabel');
+        expect(Object.keys(all[ElementTypes.Input][0].properties)).not.toContain('labelPosition');
+        expect(Object.keys(only(all, ElementTypes.SectionTitle).properties)).not.toContain('formControlName');
+    });
+    it('marks non-required properties as nullable and required ones as not', () => {
+        const toggle = only(branches(), ElementTypes.Toggle);
+        const nullable = (key) => JSON.stringify(toggle.properties[key]).includes('"null"');
+        expect(nullable('label')).toBe(false);
+        expect(nullable('formControlName')).toBe(false);
+        expect(nullable('trueLabel')).toBe(true);
+    });
+    describe('agreement with the validator', () => {
+        it('offers nothing the validator would reject as unknown', () => {
+            // Eleven members used to fail here, each one failing the WHOLE form with
+            // '"Slides > Columns > Placeholder" is not allowed'. They are declared in
+            // `baseFormColumnInputsSchema` now, so the set is empty — and this is the
+            // guard that keeps it empty when the next member is modelled.
+            expect([...JOI_UNKNOWN_COLUMN_KEYS]).toEqual([]);
+        });
+        it('does not mistake a member only the nested schema declares', () => {
+            // `formInputs` is appended by `formColumnInputsSchema`, not present on
+            // the base. Probing the base instead would report it unknown and quietly
+            // withdraw every item list — so this pins which schema is probed.
+            expect(JOI_UNKNOWN_COLUMN_KEYS.has('formInputs')).toBe(false);
+            const list = only(branches(), ElementTypes.MultipleInput);
+            expect(Object.keys(list.properties)).toContain('formInputs');
+        });
+    });
+    describe('presentation members', () => {
+        const offers = (element, key) => branches({ workflows: WORKFLOWS })[element].every((branch) => Object.keys(branch.properties).includes(key));
+        it('offers a placeholder only where text is actually typed', () => {
+            // The point of scoping through `properties` rather than offering these
+            // everywhere: a placeholder on a toggle or a date picker is meaningless,
+            // and a model handed the key will fill it in regardless.
+            expect(offers(ElementTypes.Input, 'placeholder')).toBe(true);
+            expect(offers(ElementTypes.Textarea, 'placeholder')).toBe(true);
+            expect(offers(ElementTypes.AutoCompleteInput, 'placeholder')).toBe(true);
+            expect(offers(ElementTypes.Toggle, 'placeholder')).toBe(false);
+            expect(offers(ElementTypes.DatePicker, 'placeholder')).toBe(false);
+            expect(offers(ElementTypes.FileUpload, 'placeholder')).toBe(false);
+            expect(offers(ElementTypes.SectionTitle, 'placeholder')).toBe(false);
+        });
+        it('offers affixes on the controls drawn as a form field', () => {
+            // `input` was the notable omission — a currency prefix is the canonical
+            // use of the member and the one element that could not have it.
+            for (const element of [
+                ElementTypes.Input,
+                ElementTypes.AutoCompleteInput,
+                ElementTypes.Textarea,
+                ElementTypes.Select,
+                ElementTypes.DatePicker,
+            ]) {
+                expect(offers(element, 'prefixText'))
+                    .withContext(`${element} should offer prefixText`)
+                    .toBe(true);
+            }
+            // Controls that draw their own UI have nowhere to put an affix.
+            expect(offers(ElementTypes.Signature, 'prefixText')).toBe(false);
+            expect(offers(ElementTypes.SectionTitle, 'prefixText')).toBe(false);
+        });
+        it('offers a selection cap only to the multi-select controls', () => {
+            expect(offers(ElementTypes.Select, 'selectUpto')).toBe(true);
+            expect(offers(ElementTypes.PaginatedSelectionTable, 'selectUpto')).toBe(true);
+            expect(offers(ElementTypes.WorkflowDocumentPicker, 'selectUpto')).toBe(true);
+            expect(offers(ElementTypes.Input, 'selectUpto')).toBe(false);
+            expect(offers(ElementTypes.Toggle, 'selectUpto')).toBe(false);
+        });
+        it('carries the rule that a cap needs multiple selection', () => {
+            // Skillet cannot make `selectUpto` conditional on another member's VALUE
+            // the way the calculated-field split makes it conditional on shape. The
+            // editor row states the rule, and it must survive into the description or
+            // a model will cap a single-selection control at three.
+            const description = s.getDescription(extraInputMemberSchemas[FormInputKeys.SelectUpto]);
+            expect(description).toContain('allowMultipleSelection is true');
+        });
+        it('offers row totals only to the item list', () => {
+            expect(offers(ElementTypes.MultipleInput, 'showTotalsOf')).toBe(true);
+            expect(offers(ElementTypes.Select, 'showTotalsOf')).toBe(false);
+        });
+        it('offers disabled everywhere a value is captured, and nowhere else', () => {
+            // A section title renders no control, so there is nothing to disable.
+            // Everything that captures a value can be.
+            const all = branches({ workflows: WORKFLOWS });
+            for (const element of Object.keys(all)) {
+                expect(offers(element, 'disabled'))
+                    .withContext(`${element} disabled`)
+                    .toBe(element !== ElementTypes.SectionTitle);
+            }
+        });
+        it('does not tell the model to autofill with a token it cannot use', () => {
+            // `AutocompleteOptions` is on/off only. The description used to suggest
+            // 'email' or 'tel' — values the enumeration rejects, so the instruction
+            // could not be obeyed.
+            const description = s.getDescription(extraInputMemberSchemas[FormInputKeys.Autocomplete]);
+            expect(description).not.toContain('email');
+            expect(description).not.toContain('tel ');
+        });
+    });
+    // --- the calculated-field coupling ----------------------------------------
+    describe('calculated fields', () => {
+        it('splits only the elements that can actually be numeric', () => {
+            const all = branches({ workflows: WORKFLOWS });
+            // `input` and `autoCompleteInput` let an author set both `type` and
+            // `dataType`, so either can be made numeric. `datePicker` offers `type`
+            // but pins `dataType` to date, and must not be split.
+            expect(all[ElementTypes.Input].length).toBe(2);
+            expect(all[ElementTypes.AutoCompleteInput].length).toBe(2);
+            expect(all[ElementTypes.DatePicker].length).toBe(1);
+            expect(all[ElementTypes.Toggle].length).toBe(1);
+        });
+        it('makes the rules unstateable without the calculation, and vice versa', () => {
+            const [plain, calculated] = branches()[ElementTypes.Input];
+            // The whole point: a plain field has nowhere to put rules, and a
+            // calculated one cannot omit them.
+            expect(Object.keys(plain.properties)).not.toContain('calculatedFieldRules');
+            expect(Object.keys(calculated.properties)).toContain('calculatedFieldRules');
+            expect(calculated.required).toContain('calculatedFieldRules');
+        });
+        it('pins a calculated field to number on both type and dataType', () => {
+            const [, calculated] = branches()[ElementTypes.Input];
+            expect(calculated.properties['type'].const).toBe('number');
+            expect(calculated.properties['dataType'].const).toBe('number');
+        });
+        it('never points the model at a member it cannot see', () => {
+            // The editor's applicability text for this row reads "Only applies when
+            // isCalculatedField is true". Composed in, it would name a member the
+            // schema deliberately omits — and a dangling reference is exactly how a
+            // model talks itself into inventing a key.
+            const json = JSON.stringify(s.toJsonSchema(createColumnSchema({ elements: [ElementTypes.Input] })));
+            expect(json).not.toContain('isCalculatedField');
+        });
+        it('does not ask the model for isCalculatedField at all', () => {
+            // It is derivable from whether the rules are present, and a value a model
+            // supplies is a value it can contradict. Skillet also has no boolean
+            // literal to pin it with. The application sets it on expansion.
+            for (const branch of branches()[ElementTypes.Input]) {
+                expect(Object.keys(branch.properties)).not.toContain('isCalculatedField');
+            }
+        });
+        it('binds calculation variables by control name, never by id', () => {
+            const json = columnJson();
+            const [, calculated] = branches()[ElementTypes.Input];
+            const rules = JSON.stringify(deref(json, calculated.properties['calculatedFieldRules']));
+            expect(rules).toContain('formControlName');
+            // `inputId` is stamped by the application. Asking a model for it yields a
+            // plausible string pointing at nothing, and a formula that silently
+            // computes nothing.
+            expect(rules).not.toContain('inputId');
+        });
+    });
+    // --- nested item lists ----------------------------------------------------
+    describe('item lists', () => {
+        it('gives a list its contents', () => {
+            const list = only(branches(), ElementTypes.MultipleInput);
+            expect(Object.keys(list.properties)).toContain('formInputs');
+            // `formInputs` is one of the element's `requiredProperties`; a list with
+            // no contents is not a list.
+            expect(list.required).toContain('formInputs');
+        });
+        it('withdraws the list entirely once nesting is exhausted', () => {
+            // The element cannot be offered without its required contents, so at
+            // depth 0 it goes rather than being emitted incomplete.
+            const shallow = branches({ depth: 0 });
+            expect(Object.keys(shallow)).not.toContain(ElementTypes.MultipleInput);
+        });
+        it('does not put a section heading inside a list', () => {
+            // `validateForm()` strips section titles from a SLIDE, not from
+            // `formInputs`, which Joi validates through `Joi.link` against the full
+            // column schema — so a nested heading would be required to carry a
+            // formControlName it is deliberately built without.
+            const list = only(branches(), ElementTypes.MultipleInput);
+            const nested = JSON.stringify(list.properties['formInputs']);
+            expect(nested).toContain(ElementTypes.Input);
+            expect(nested).not.toContain(`"const":"${ElementTypes.SectionTitle}"`);
+        });
+        it('stops recursing rather than nesting forever', () => {
+            // Skillet has no recursive node, so the nesting is unrolled to a fixed
+            // depth. One level deep, the list's contents must contain no further list.
+            const list = only(branches(), ElementTypes.MultipleInput);
+            const nested = JSON.stringify(list.properties['formInputs']);
+            expect(nested).not.toContain(`"const":"${ElementTypes.MultipleInput}"`);
+        });
+    });
+    // --- end to end -----------------------------------------------------------
+    it('produces a draft that passes validateForm once expanded', () => {
+        // The contract this whole module exists to satisfy: what a model emits,
+        // put through the expansion the application owes it, must satisfy the
+        // existing validator. This covers the two hardest shapes — a calculated
+        // field and a nested item list — alongside both validator branches.
+        const draft = {
+            formTitle: 'Supplier registration',
+            slides: [
+                {
+                    label: 'Company details',
+                    columns: [
+                        {
+                            element: 'sectionTitle',
+                            label: 'Company details',
+                            appearance: 'outline',
+                            hintLabel: null,
+                        },
+                        {
+                            element: 'input',
+                            label: 'Company name',
+                            formControlName: 'companyName',
+                            appearance: 'outline',
+                            required: true,
+                            dataType: 'string',
+                            type: 'text',
+                            colSize: 12,
+                            hintLabel: null,
+                            matOptions: null,
+                            pattern: null,
+                            validators: [
+                                'email',
+                                {
+                                    message: 'Company name must differ from the trading name.',
+                                    expression: 'companyName !== tradingName',
+                                    canOverride: true,
+                                    inputsObservedForChanges: [
+                                        {
+                                            formControlName: 'tradingName',
+                                            variable: 'tradingName',
+                                            parentInputFormControl: null,
+                                            function: null,
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            element: 'multipleInput',
+                            label: 'Directors',
+                            formControlName: 'directors',
+                            appearance: 'outline',
+                            handleLabel: 'Add director',
+                            colSize: 12,
+                            dataType: 'array',
+                            required: true,
+                            formInputs: [
+                                {
+                                    element: 'input',
+                                    label: 'Director name',
+                                    formControlName: 'directorName',
+                                    appearance: 'outline',
+                                    required: true,
+                                    dataType: 'string',
+                                    type: 'text',
+                                    colSize: 6,
+                                },
+                                {
+                                    element: 'input',
+                                    label: 'Shareholding',
+                                    formControlName: 'shareholding',
+                                    appearance: 'outline',
+                                    required: true,
+                                    dataType: 'number',
+                                    type: 'number',
+                                    colSize: 6,
+                                },
+                            ],
+                        },
+                        {
+                            element: 'input',
+                            label: 'Total shareholding',
+                            formControlName: 'totalShareholding',
+                            appearance: 'outline',
+                            required: true,
+                            type: 'number',
+                            dataType: 'number',
+                            colSize: 6,
+                            calculatedFieldRules: {
+                                formula: 'total',
+                                variables: [
+                                    {
+                                        bindingType: 'listAggregate',
+                                        variable: 'total',
+                                        label: 'Total shareholding',
+                                        formControlName: 'shareholding',
+                                        parentInputFormControl: 'directors',
+                                        function: 'sum',
+                                        applyFunctionToCol: 'shareholding',
+                                        applyFunctionToLabel: null,
+                                        filterValuesByCol: null,
+                                        filterValuesByThisColLabel: null,
+                                        tableCell: null,
+                                    },
+                                ],
+                                decimalPlaces: 2,
+                                roundingMode: 'ROUND',
+                                getFormulaFromAFormInput: null,
+                                formControlWithFormula: null,
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+        /**
+         * The expansion the application owes a draft, written out so the test
+         * exercises the real obligation rather than a convenient subset of it.
+         */
+        let seq = 0;
+        const nextId = () => `id-${++seq}`;
+        const stripNulls = (value) => {
+            if (Array.isArray(value))
+                return value.map(stripNulls);
+            if (value && typeof value === 'object') {
+                return Object.fromEntries(Object.entries(value)
+                    .filter(([, v]) => v !== null)
+                    .map(([k, v]) => [k, stripNulls(v)]));
+            }
+            return value;
+        };
+        const expandValidators = (validators) => (validators ?? []).map((entry) => typeof entry === 'string'
+            ? entry
+            : {
+                ...entry,
+                id: nextId(),
+                inputsObservedForChanges: (entry
+                    .inputsObservedForChanges ?? []).map((observed) => {
+                    const { formControlName, parentInputFormControl, ...rest } = observed;
+                    return {
+                        ...rest,
+                        inputId: `input-${String(formControlName)}`,
+                        ...(parentInputFormControl
+                            ? { parentInputId: `input-${String(parentInputFormControl)}` }
+                            : {}),
+                    };
+                }),
+            });
+        const expandRules = (rules) => rules && {
+            ...rules,
+            variables: rules['variables'].map(({ bindingType: _dropped, ...variable }) => ({
+                ...variable,
+                id: nextId(),
+                inputId: `input-${String(variable['formControlName'])}`,
+            })),
+        };
+        const expandColumn = (column, sectionId) => {
+            const rules = expandRules(column['calculatedFieldRules']);
+            return {
+                ...column,
+                id: nextId(),
+                sectionId,
+                // Derived, never authored — see `calculatedFieldSplit` in variants.ts.
+                isCalculatedField: rules != null,
+                onlySetTempErrorOnTouch: false,
+                validators: expandValidators(column['validators']),
+                ...(rules ? { calculatedFieldRules: rules } : {}),
+                ...(column['formInputs']
+                    ? {
+                        formInputs: column['formInputs'].map((nested) => expandColumn(nested, sectionId)),
+                    }
+                    : {}),
+            };
+        };
+        const cleaned = stripNulls(draft);
+        const expanded = {
+            formTitle: cleaned.formTitle,
+            slides: cleaned.slides.map((slide, i) => ({
+                sectionId: `sec-${i}`,
+                label: slide.label,
+                columns: slide.columns.map((column) => expandColumn(column, `sec-${i}`)),
+            })),
+            submissionHandle: {
+                submissionMessage: 'Registration received.',
+                submissionAPI: [
+                    {
+                        _id: '65f0a1',
+                        name: 'Register supplier',
+                        httpEndPoint: '/api/suppliers',
+                        httpMethod: 'POST',
+                        postFormData: true,
+                        source: 'api',
+                        backEndConfig: { minimumInputRequired: [] },
+                    },
+                ],
+            },
+        };
+        expect(validateForm(expanded)).toEqual([]);
+    });
+    it('lets every branch produce a column the validator accepts', () => {
+        // The broadest guarantee available, and the one that generalises: rather
+        // than hand-writing a form and checking it, this walks EVERY branch of the
+        // union, builds a column populating EVERY member that branch offers,
+        // applies exactly the expansion `DRAFT_COMPLETION_REQUIRED` declares, and
+        // validates it.
+        //
+        // Populating every member, not just the required ones, is what makes this
+        // catch the class of bug that motivated it: `placeholder` was offered by
+        // three elements and rejected outright by the validator, and a column built
+        // from required keys alone would never have carried one. Any member the
+        // schema offers is a member some generated form will contain.
+        //
+        // So it proves three things at once — that no element can be asked for
+        // something it cannot produce validly, that every offered member is
+        // acceptable to the validator, and that the declared completion list is
+        // SUFFICIENT rather than merely descriptive. A new element, or a member
+        // that quietly starts needing expansion, fails here without anyone
+        // remembering to write a case for it.
+        const json = columnJson({
+            workflows: WORKFLOWS,
+            apiEndpoints: [{ id: 'ep-1', name: 'Departments' }],
+        });
+        /** A value a node accepts, filling every member it declares. */
+        const generate = (node, key) => {
+            const n = deref(json, node);
+            if (n.anyOf) {
+                const branch = n.anyOf.find((b) => deref(json, b)?.type !== 'null') ?? n.anyOf[0];
+                return generate(branch, key);
+            }
+            if (n.const !== undefined)
+                return n.const;
+            if (n.enum)
+                return n.enum[0];
+            switch (n.type) {
+                case 'string':
+                    return key === 'formControlName' ? 'aField' : 'x';
+                case 'number':
+                case 'integer':
+                    return n.minimum ?? 1;
+                case 'boolean':
+                    return true;
+                case 'null':
+                    return null;
+                case 'array':
+                    return [generate(n.items, key)];
+                case 'object': {
+                    const out = {};
+                    for (const k of Object.keys(n.properties ?? {})) {
+                        out[k] = generate(n.properties[k], k);
+                    }
+                    return out;
+                }
+                default:
+                    return 'x';
+            }
+        };
+        /** Drops the nulls an unset member arrives as; Joi rejects them. */
+        const stripNulls = (value) => {
+            if (Array.isArray(value))
+                return value.map(stripNulls);
+            if (value && typeof value === 'object') {
+                return Object.fromEntries(Object.entries(value)
+                    .filter(([, v]) => v !== null)
+                    .map(([k, v]) => [k, stripNulls(v)]));
+            }
+            return value;
+        };
+        let seq = 0;
+        const nextId = () => `x${++seq}`;
+        const stamp = (rows) => (rows ?? []).map((row) => ({ ...row, id: nextId() }));
+        const expand = (input) => {
+            const out = {
+                ...input,
+                id: nextId(),
+                sectionId: 's1',
+                isCalculatedField: input['calculatedFieldRules'] != null,
+                onlySetTempErrorOnTouch: false,
+                validators: input['validators'] ?? [],
+            };
+            if (out['calculatedFieldRules']) {
+                out['calculatedFieldRules'] = {
+                    ...out['calculatedFieldRules'],
+                    variables: out['calculatedFieldRules'].variables.map(({ bindingType: _drop, ...variable }) => ({
+                        ...variable,
+                        id: nextId(),
+                        inputId: `i-${String(variable['formControlName'])}`,
+                    })),
+                };
+            }
+            out['validators'] = out['validators'].map((entry) => typeof entry === 'string'
+                ? entry
+                : {
+                    ...entry,
+                    id: nextId(),
+                    inputsObservedForChanges: (entry
+                        .inputsObservedForChanges ?? []).map(({ formControlName, parentInputFormControl: _p, ...rest }) => ({
+                        ...rest,
+                        inputId: `i-${String(formControlName)}`,
+                    })),
+                });
+            if (out['mscoaConfig']) {
+                out['mscoaConfig'] = {
+                    ...out['mscoaConfig'],
+                    inputs: [],
+                    segments: stamp(out['mscoaConfig'].segments),
+                    ...(out['mscoaConfig'].cashSegments
+                        ? { cashSegments: stamp(out['mscoaConfig'].cashSegments) }
+                        : {}),
+                };
+            }
+            if (out['paginationSelectionConfig']) {
+                out['paginationSelectionConfig'] = {
+                    ...out['paginationSelectionConfig'],
+                    columns: stamp(out['paginationSelectionConfig'].columns),
+                };
+            }
+            // `CALCULATE_LIST_DRAFT_COMPLETION`: the roll-up names the column it
+            // totals by `formControlName`, which is NOT a member of
+            // `IMultipleInputCal` — the application stamps an `id`, resolves the name
+            // to the aggregated column's `inputId`, and drops the name.
+            if (out['calculateListFunctions']) {
+                out['calculateListFunctions'] = out['calculateListFunctions'].map(({ formControlName, ...rest }) => ({
+                    ...rest,
+                    id: nextId(),
+                    inputId: `i-${String(formControlName)}`,
+                }));
+            }
+            // `endpointId` and `workflowId` are draft-only and are expanded away.
+            if (out['matOptions']?.fetch) {
+                const shed = (side) => {
+                    if (!side)
+                        return side;
+                    const { endpointId: _e, workflowId: _w, ...rest } = side;
+                    return rest;
+                };
+                out['matOptions'] = {
+                    ...out['matOptions'],
+                    fetch: {
+                        value: shed(out['matOptions'].fetch.value),
+                        options: shed(out['matOptions'].fetch.options),
+                    },
+                };
+            }
+            if (out['formInputs']) {
+                out['formInputs'] = out['formInputs'].map(expand);
+            }
+            return out;
+        };
+        const failures = json.anyOf
+            .map((branch) => ({
+            element: branch.properties.element.const,
+            errors: validateFormColumnInputs(expand(stripNulls(generate(branch)))),
+        }))
+            .filter((result) => result.errors.length);
+        expect(failures).toEqual([]);
+    });
+    it('shrinks materially when narrowed to the common elements', () => {
+        const full = JSON.stringify(s.toJsonSchema(createColumnSchema())).length;
+        const common = JSON.stringify(s.toJsonSchema(createColumnSchema({ elements: COMMON_ELEMENTS }))).length;
+        expect(common).toBeLessThan(full);
+    });
+    it('never offers the deprecated submit-button flag', () => {
+        const json = JSON.stringify(s.toJsonSchema(createFormDraftSchema({ elements: COMMON_ELEMENTS })));
+        expect(json).not.toContain('innerComponentShowSubmitButton');
+    });
+    it('offers no submission endpoint when none were supplied', () => {
+        const json = JSON.stringify(s.toJsonSchema(createFormDraftSchema({ elements: COMMON_ELEMENTS })));
+        expect(json).toContain('Leave empty');
+        expect(json).not.toContain('httpEndPoint');
+    });
+});