ngx-t-forms-types 0.0.30 → 0.0.33

package/dist/skillet/shared-types.d.ts

@@ -0,0 +1,57 @@
+import { s } from '@hashbrownai/core';
+import { AdjudicationSteps, AutocompleteOptions, AutocapitalizeOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput/index.js';
+import { DataSources } from '../interfaces/formInput/APIDataFetchingConfigurationInterface.js';
+import { InputViewTypes, OptionSelectTypes } from '../interfaces/formInput/BasicFormInputInterface.js';
+import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface.js';
+import { AccountingBasis } from '../interfaces/formInput/IMscoaAccount.js';
+import { MultipleInputAvailableOperations } from '../interfaces/formInput/MultipleInterface.js';
+import { RichTextEditorType } from '../interfaces/formInput/RichTextEditorInput.js';
+import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface.js';
+/**
+ * Skillet nodes for the shared vocabulary — every closed set of values a form
+ * input can carry.
+ *
+ * Enum-backed nodes call {@link enumValues}, so their entries are read off the
+ * live enum at module evaluation. There is no list here to fall out of date:
+ * adding `ElementTypes.Foo` puts `'foo'` in the schema and widens `s.Infer`
+ * automatically. Only the DESCRIPTION is authored, and the description is the
+ * part that actually steers the model.
+ *
+ * Union-backed nodes (types with no runtime object to read) go through
+ * {@link exhaustive}, which fails to compile if the restated tuple drifts from
+ * the union.
+ */
+export declare const elementTypeSchema: s.EnumType<ElementTypes[]>;
+export declare const inputTypeSchema: s.EnumType<InputTypes[]>;
+export declare const inputDataTypeSchema: s.EnumType<InputDataTypes[]>;
+export declare const inputViewTypeSchema: s.EnumType<InputViewTypes.ViewOnly[]>;
+/**
+ * `MatFormFieldAppearance` is a string-union type, not an enum, so its members
+ * are restated here under {@link exhaustive} rather than derived.
+ */
+export declare const APPEARANCE_VALUES: readonly ["fill", "outline"];
+export declare const appearanceSchema: s.EnumType<["fill", "outline"]>;
+export declare const labelPositionSchema: s.EnumType<LabelPosition[]>;
+export declare const optionSelectTypeSchema: s.EnumType<OptionSelectTypes[]>;
+/**
+ * `AutocompleteOptions` is a two-member enum — `on` and `off`.
+ *
+ * The description used to tell the model to "use a specific token such as email
+ * or tel", which is what the HTML `autocomplete` attribute accepts but NOT what
+ * this enum offers. A model following it emitted `email`, which is not a member,
+ * so the value was rejected — an instruction the schema itself made impossible
+ * to obey. Derived entries and authored prose have to agree, and here only the
+ * prose could be wrong.
+ */
+export declare const autocompleteSchema: s.EnumType<AutocompleteOptions[]>;
+export declare const autocapitalizeSchema: s.EnumType<AutocapitalizeOptions[]>;
+/** `wrap` is declared inline on the textarea interface as a string union. */
+export declare const TEXTAREA_WRAP_VALUES: readonly ["hard", "soft"];
+export declare const textareaWrapSchema: s.EnumType<["hard", "soft"]>;
+export declare const inputPipeTypeSchema: s.EnumType<InputPipeTypes[]>;
+export declare const richTextEditorTypeSchema: s.EnumType<RichTextEditorType[]>;
+export declare const inputFileTypeSchema: s.EnumType<InputFileType[]>;
+export declare const dataSourceSchema: s.EnumType<DataSources[]>;
+export declare const multipleInputOperationSchema: s.EnumType<MultipleInputAvailableOperations[]>;
+export declare const adjudicationStepSchema: s.EnumType<AdjudicationSteps[]>;
+export declare const accountingBasisSchema: s.EnumType<AccountingBasis[]>;

package/dist/skillet/shared-types.js

@@ -0,0 +1,69 @@
+import { s } from '@hashbrownai/core';
+import { AdjudicationSteps, AutocompleteOptions, AutocapitalizeOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes, } from '../interfaces/formInput/index.js';
+import { DataSources } from '../interfaces/formInput/APIDataFetchingConfigurationInterface.js';
+import { InputViewTypes, OptionSelectTypes, } from '../interfaces/formInput/BasicFormInputInterface.js';
+import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface.js';
+import { AccountingBasis } from '../interfaces/formInput/IMscoaAccount.js';
+import { MultipleInputAvailableOperations } from '../interfaces/formInput/MultipleInterface.js';
+import { RichTextEditorType } from '../interfaces/formInput/RichTextEditorInput.js';
+import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface.js';
+import { enumValues, exhaustive } from './internal/coupling.js';
+import { describe } from './internal/editor-guidance.js';
+/**
+ * Skillet nodes for the shared vocabulary — every closed set of values a form
+ * input can carry.
+ *
+ * Enum-backed nodes call {@link enumValues}, so their entries are read off the
+ * live enum at module evaluation. There is no list here to fall out of date:
+ * adding `ElementTypes.Foo` puts `'foo'` in the schema and widens `s.Infer`
+ * automatically. Only the DESCRIPTION is authored, and the description is the
+ * part that actually steers the model.
+ *
+ * Union-backed nodes (types with no runtime object to read) go through
+ * {@link exhaustive}, which fails to compile if the restated tuple drifts from
+ * the union.
+ */
+// --- Element identity -------------------------------------------------------
+export const elementTypeSchema = s.enumeration(describe('The kind of control to render. This determines which other properties are meaningful, so choose it first and let it drive the rest.', 'element'), enumValues(ElementTypes));
+export const inputTypeSchema = s.enumeration(describe("The native HTML input type, for elements that render an <input>. Match it to the data: 'number' for a quantity, an amount or a percentage; 'email'; 'tel' for a phone number; 'url'; 'password' for a one-time code; 'date' for a memorable date typed from memory such as a date of birth; 'time' or 'month'; 'text' for names, references and codes.", 'type'), enumValues(InputTypes));
+export const inputDataTypeSchema = s.enumeration(describe("The JavaScript type the captured value is stored as: 'number' for a numeric input or a calculated field, 'boolean' for a toggle, 'date' for a date picker, 'array' for an item list, 'object' for a file, a location or an account picker, 'string' for everything else.", 'dataType'), enumValues(InputDataTypes));
+export const inputViewTypeSchema = s.enumeration(describe('Renders the control as read-only presentation rather than an editable field.', 'viewType'), enumValues(InputViewTypes));
+// --- Presentation -----------------------------------------------------------
+/**
+ * `MatFormFieldAppearance` is a string-union type, not an enum, so its members
+ * are restated here under {@link exhaustive} rather than derived.
+ */
+export const APPEARANCE_VALUES = exhaustive()([
+    'fill',
+    'outline',
+]);
+export const appearanceSchema = s.enumeration(describe("The Material form-field style. Use 'outline' unless the surrounding form already uses 'fill'; do not mix the two within one form.", 'appearance'), [...APPEARANCE_VALUES]);
+export const labelPositionSchema = s.enumeration(describe("Which side of a toggle its label sits on. Use 'after'.", 'labelPosition'), enumValues(LabelPosition));
+export const optionSelectTypeSchema = s.enumeration(describe("How a set of options is presented: 'radioButton' for one choice from two to five fixed options, so the user can scan them all at once; 'dropDown' for six or more, sorted alphabetically unless there is a natural order; 'chipSelect' when several options are chosen together from a short list. A short list left as a dropdown is a common mistake.", 'optionSelectType'), enumValues(OptionSelectTypes));
+/**
+ * `AutocompleteOptions` is a two-member enum — `on` and `off`.
+ *
+ * The description used to tell the model to "use a specific token such as email
+ * or tel", which is what the HTML `autocomplete` attribute accepts but NOT what
+ * this enum offers. A model following it emitted `email`, which is not a member,
+ * so the value was rejected — an instruction the schema itself made impossible
+ * to obey. Derived entries and authored prose have to agree, and here only the
+ * prose could be wrong.
+ */
+export const autocompleteSchema = s.enumeration(describe('Whether the browser may autofill this field from the user profile.', 'autocomplete'), enumValues(AutocompleteOptions));
+export const autocapitalizeSchema = s.enumeration(describe("How the on-screen keyboard capitalises typed text. Use 'words' for names and 'characters' for reference codes.", 'autocapitalize'), enumValues(AutocapitalizeOptions));
+/** `wrap` is declared inline on the textarea interface as a string union. */
+export const TEXTAREA_WRAP_VALUES = exhaustive()([
+    'hard',
+    'soft',
+]);
+export const textareaWrapSchema = s.enumeration(describe("How a textarea wraps long lines when the form is submitted. 'soft' leaves the text unchanged; 'hard' inserts real newlines at the wrap points.", 'wrap'), [...TEXTAREA_WRAP_VALUES]);
+export const inputPipeTypeSchema = s.enumeration(describe('A display transform applied to the value when it is shown back to the user. This is presentation only and never changes the stored value.', 'pipe', 'pipeType'), enumValues(InputPipeTypes));
+export const richTextEditorTypeSchema = s.enumeration(describe('Which rich-text editor library backs an editor element.', 'richTextEditorLibrary'), enumValues(RichTextEditorType));
+export const inputFileTypeSchema = s.enumeration(describe("The kind of upload a file control accepts: 'file' for a document such as a quote, an invoice or a certificate; 'captureImage' for a photo taken on the phone camera; 'image' for a picture from disk.", 'fileType'), enumValues(InputFileType));
+// --- Data sourcing ----------------------------------------------------------
+export const dataSourceSchema = s.enumeration("Where a control's options come from: values typed into the form definition, an HTTP endpoint, a MongoDB aggregation pipeline, or a custom option set.", enumValues(DataSources));
+// --- Domain-specific --------------------------------------------------------
+export const multipleInputOperationSchema = s.enumeration(describe('An operation a user may perform on the rows of a repeatable multiple-input group.', 'multipleInputAvailableOperations'), enumValues(MultipleInputAvailableOperations));
+export const adjudicationStepSchema = s.enumeration(describe('Which stage of the tender adjudication workflow this control belongs to.', 'adjudicationStep'), enumValues(AdjudicationSteps));
+export const accountingBasisSchema = s.enumeration("The accounting basis an mSCOA account selection is resolved against. 'accrual' is the usual choice for a budget capture; 'dual' only when the form genuinely captures the cash side as well.", enumValues(AccountingBasis));

package/dist/skillet/tests/house-rules.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/skillet/tests/house-rules.spec.js

@@ -0,0 +1,162 @@
+import { s } from '@hashbrownai/core';
+import { AllFormInputPrimaryKeys } from '../../interfaces/FormBuilder/FormInputKeys.js';
+import { ElementTypes } from '../../interfaces/formInput/index.js';
+import { AUTHORING_RULES, CONTROL_NAME_PATTERN } from '../authoring-rules.js';
+import { DRAFT_COMPLETION_REQUIRED, createFormDraftSchema } from '../form.js';
+import { inputMemberSchemas } from '../input-members.js';
+import { createValidatorsSchema, validatorsDraftSchema, } from '../members/validators.js';
+import { COMMON_ELEMENTS, createColumnSchema } from '../variants.js';
+import { RESERVED_CONTROL_NAMES, describeWorkflowStep, } from '../workflow-context.js';
+/**
+ * The rules the schemas carry from the Form Creation Guide
+ * (`doc/guides/form-creation-guide.md`) that a test can hold them to.
+ *
+ * Most of the guide arrives as prose in descriptions, which no test can judge.
+ * What can be pinned is the handful of places where the prose and a structure
+ * have to agree — the reserved names against the control-name pattern, the
+ * step context against the form description, an element the description
+ * names against the elements on offer — and the two rules the guide overturned
+ * outright: the autocomplete note and the handle-label description.
+ */
+describe('house rules from the Form Creation Guide', () => {
+    it('names every reserved control name the pattern would let through', () => {
+        // The pattern stops `_id` and the SYSTEM_* inputs on shape alone. The
+        // ones it lets through — `reference`, `status`, `data` — have to be named
+        // in the rules, or the model has no way to know them. Filtering at
+        // evaluation rather than listing by hand is what this pins: add a
+        // lowerCamelCase name to RESERVED_CONTROL_NAMES and it appears here.
+        const pattern = new RegExp(CONTROL_NAME_PATTERN);
+        const rules = AUTHORING_RULES.join(' ');
+        const uncovered = RESERVED_CONTROL_NAMES.filter((name) => pattern.test(name) && !new RegExp(`\\b${name}\\b`).test(rules));
+        expect(uncovered).toEqual([]);
+        expect(pattern.test('_id')).toBe(false);
+        expect(pattern.test('SYSTEM_TAGS')).toBe(false);
+        expect(pattern.test('CURRENT_FINANCIAL_CYCLE')).toBe(false);
+        expect(rules).toContain('reference');
+    });
+    it('states the rules once, at the root of the form', () => {
+        // Hashbrown names `$defs` entries by description and repeats the name at
+        // every `$ref`, so a rule on a member every element shares is paid once
+        // per element. The root is emitted once, so that is where the rules go —
+        // and the member the rule concerns must NOT repeat it.
+        const json = s.toJsonSchema(createFormDraftSchema({ elements: COMMON_ELEMENTS }));
+        expect(json.description).toContain('never one of the names');
+        expect(json.description).toContain('reference');
+        const member = s.getDescription(inputMemberSchemas[AllFormInputPrimaryKeys.FormControlName]) ?? '';
+        expect(member).not.toContain('reference,');
+        expect(member.length).toBeLessThan(400);
+    });
+    it('withdraws the named-validator branch until names are supplied', () => {
+        // Same reasoning as the api source and the document picker: a free string
+        // invites a validator name that looks authoritative and resolves to
+        // nothing. With no names the item is the inline rule alone; with names it
+        // is a union whose string branch enumerates exactly those names.
+        const items = (json) => json
+            .properties.__wrappedPrimitive.items;
+        const bare = items(s.toJsonSchema(validatorsDraftSchema));
+        expect(bare.anyOf).toBeUndefined();
+        expect(bare.type).toBe('object');
+        const named = items(s.toJsonSchema(createValidatorsSchema({
+            namedValidators: [
+                { name: 'email', description: 'a well-formed email address' },
+            ],
+        })));
+        expect(Array.isArray(named.anyOf)).toBe(true);
+        const text = JSON.stringify(named.anyOf);
+        expect(text).toContain('"enum"');
+        expect(text).toContain('"email"');
+        expect(text).toContain('a well-formed email address');
+        expect(named.anyOf.some((b) => b.type === 'object')).toBe(true);
+    });
+    it('threads the named validators through the column options', () => {
+        const json = JSON.stringify(s.toJsonSchema(createColumnSchema({
+            elements: [ElementTypes.Input],
+            namedValidators: [{ name: 'southAfricanId' }],
+        })));
+        expect(json).toContain('southAfricanId');
+        const bare = JSON.stringify(s.toJsonSchema(createColumnSchema({ elements: [ElementTypes.Input] })));
+        expect(bare).not.toContain('southAfricanId');
+    });
+    it('tells the model which step the form serves', () => {
+        const json = JSON.stringify(s.toJsonSchema(createFormDraftSchema({
+            elements: COMMON_ELEMENTS,
+            step: {
+                type: 'review',
+                controlName: 'managerReview',
+                expectedControls: [
+                    {
+                        name: 'totalAmount',
+                        purpose: 'decision gate compares it against 30000',
+                    },
+                ],
+                prefilledControlNames: ['department'],
+            },
+        })));
+        expect(json).toContain('serves the review step');
+        expect(json).toContain("'managerReview'");
+        expect(json).toContain('totalAmount');
+        expect(json).toContain('decision gate compares it against 30000');
+        expect(json).toContain("'department'");
+    });
+    it('says nothing about a workflow step unless one was given', () => {
+        const json = JSON.stringify(s.toJsonSchema(createFormDraftSchema({ elements: COMMON_ELEMENTS })));
+        expect(json).not.toContain('serves the');
+    });
+    it('asks for the review control name when it was not supplied', () => {
+        // A review step routes on one toggle, and its name is the workflow
+        // designer's. Without it the model must be told to get it from the
+        // request rather than left to pick one.
+        expect(describeWorkflowStep({ type: 'review' })).toContain('which the request must state');
+        expect(describeWorkflowStep({ type: 'initiate' })).toContain('never ask the user for it');
+    });
+    it('points the model at section titles only when they are on offer', () => {
+        // A sentence naming an element the union does not contain is how a model
+        // talks itself into inventing one.
+        const withHeadings = JSON.stringify(s.toJsonSchema(createFormDraftSchema({ elements: COMMON_ELEMENTS })));
+        expect(withHeadings).toContain('sectionTitle whose hintLabel');
+        const without = JSON.stringify(s.toJsonSchema(createFormDraftSchema({ elements: [ElementTypes.Input] })));
+        expect(without).not.toContain('sectionTitle whose hintLabel');
+    });
+    it('offers the always-shown settings on every element that captures a value', () => {
+        // `readonly`, `onlySetTempErrorOnTouch` and `tourContent` are edited
+        // through `Default` rows, which the settings panel shows on every element
+        // and which no element's `properties` lists. The guide treats the first
+        // two as settings set on nearly every field — a prefilled value is
+        // read-only, errors wait for the user to leave the field — and the step
+        // context tells the model to use `readonly`, so it has to be there.
+        const json = s.toJsonSchema(createColumnSchema({ elements: COMMON_ELEMENTS }));
+        for (const branch of json.anyOf) {
+            const keys = Object.keys(branch.properties);
+            const element = branch.properties['element'].const;
+            const captures = element !== ElementTypes.SectionTitle;
+            for (const key of ['readonly', 'onlySetTempErrorOnTouch', 'tourContent']) {
+                expect(keys.includes(key))
+                    .withContext(`${element} ${captures ? 'should' : 'should not'} offer ${key}`)
+                    .toBe(captures);
+            }
+        }
+        // The interface requires the flag and the schema leaves it optional, so
+        // the application still owes a default — and the guide says which.
+        const entry = DRAFT_COMPLETION_REQUIRED.find((path) => path.startsWith('slides[].columns[].onlySetTempErrorOnTouch'));
+        expect(entry).toBeDefined();
+        expect(entry).toContain('true');
+    });
+    it('describes the item-list handle as a row button, not a file control', () => {
+        // `handleLabel` is declared by `IMultiple` and listed only by the item
+        // list, yet its description used to speak of "the attached file".
+        const description = s.getDescription(inputMemberSchemas[AllFormInputPrimaryKeys.HandleLabel]) ??
+            '';
+        expect(description).toContain('Add item');
+        expect(description).not.toContain('file');
+    });
+    it('steers the autocomplete by whether the user may add a value, not by list length', () => {
+        // The guide draws the line the old note did not: an autocomplete stores
+        // whatever is typed, so it is for a list the user may add to; a merely
+        // long list is a paginated selection table.
+        const json = s.toJsonSchema(createColumnSchema({ elements: [ElementTypes.AutoCompleteInput] }));
+        const notes = json.anyOf.map((branch) => branch.description ?? '').join(' ');
+        expect(notes).toContain('stores whatever the user types');
+        expect(notes).toContain('paginatedSelectionTable');
+        expect(notes).not.toContain('Prefer it over a select when the list is long');
+    });
+});

package/dist/skillet/tests/skillet-coupling.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/skillet/tests/skillet-coupling.spec.js

@@ -0,0 +1,191 @@
+import { s } from '@hashbrownai/core';
+import { AllFormInputPrimaryKeys, FormInputKeys, SpecialElementKeys, } from '../../interfaces/FormBuilder/FormInputKeys.js';
+import { DRAFT_COMPLETION_REQUIRED } from '../form.js';
+import { ElementTypes } from '../../interfaces/formInput/index.js';
+import { DataSources } from '../../interfaces/formInput/APIDataFetchingConfigurationInterface.js';
+import { ASSEMBLED_INPUT_MEMBERS, DEPRECATED_INPUT_MEMBERS, DRAFT_INPUT_MEMBERS, draftMemberSchemas, PENDING_INPUT_MEMBERS, SYSTEM_OWNED_INPUT_MEMBERS, inputMemberSchemas, } from '../input-members.js';
+import { ALWAYS_SHOWN_MEMBERS, SECONDARY_GUIDED_PATHS, UNREADABLE_EXPRESSIONS, describeIn, } from '../internal/editor-guidance.js';
+import { createMatOptionsSchema } from '../members/mat-options.js';
+import { createWorkflowPickerSchema } from '../members/document-picker.js';
+import { createValidatorsSchema } from '../members/validators.js';
+import { elementTypeSchema } from '../shared-types.js';
+/**
+ * Covers the invariants the compiler cannot reach.
+ *
+ * The type-level assertions in `input-members.ts` already prove that every key
+ * is classified and that no node produces a value its interface cannot hold —
+ * those fail the build, so they need no test. What is left is everything that
+ * depends on runtime values: whether the derivation actually found the guidance
+ * it was pointed at, and whether the enum-derived nodes really carry the
+ * members their enums declare.
+ */
+describe('skillet coupling', () => {
+    it('reads every applicability expression in the editor config', () => {
+        // The expression grammar is closed today — `key === value` joined by `||`.
+        // Reaching for `&&` or `!==` in ElementEditConfig would leave the rule
+        // unparsed and silently drop that guidance from the schema, so the failure
+        // has to surface somewhere. It surfaces here.
+        expect(UNREADABLE_EXPRESSIONS).toEqual([]);
+    });
+    it('classifies every key exactly once', () => {
+        const categories = [
+            Object.keys(inputMemberSchemas),
+            [...PENDING_INPUT_MEMBERS],
+            [...SYSTEM_OWNED_INPUT_MEMBERS],
+            [...DEPRECATED_INPUT_MEMBERS],
+            [...DRAFT_INPUT_MEMBERS],
+            [...ASSEMBLED_INPUT_MEMBERS],
+        ].flat();
+        const enumKeys = Object.values(AllFormInputPrimaryKeys);
+        expect(categories.length).toBe(enumKeys.length);
+        expect(new Set(categories).size).toBe(categories.length);
+        expect([...categories].sort()).toEqual([...enumKeys].sort());
+    });
+    it('gives every modelled member a description', () => {
+        const undescribed = Object.entries(inputMemberSchemas)
+            .filter(([, node]) => {
+            const description = s.getDescription(node);
+            // Union nodes carry their descriptions on the branches rather than the
+            // node itself, so an empty description there is expected.
+            return description !== undefined && description.trim() === '';
+        })
+            .map(([key]) => key);
+        expect(undescribed).toEqual([]);
+    });
+    it('derives element options from the live enum, not a copied list', () => {
+        const json = s.toJsonSchema(elementTypeSchema);
+        const entries = json.properties.__wrappedPrimitive.enum;
+        expect([...entries].sort()).toEqual([...Object.values(ElementTypes)].sort());
+        // Members commented out of `ElementTypes` must not reappear. A hand-copied
+        // list is exactly how they would.
+        expect(entries).not.toContain('qrCodeScanner');
+        expect(entries).not.toContain('matrixTable');
+    });
+    it('excludes deprecated and system-owned members from generation', () => {
+        const modelled = Object.keys(inputMemberSchemas);
+        for (const key of DEPRECATED_INPUT_MEMBERS) {
+            expect(modelled).not.toContain(key);
+        }
+        for (const key of SYSTEM_OWNED_INPUT_MEMBERS) {
+            expect(modelled).not.toContain(key);
+        }
+    });
+    it('never offers an api source unless endpoints were supplied', () => {
+        // The whole point of the factory. With no endpoint list there is nothing
+        // for a model to select, so the branch must not exist — otherwise it
+        // invents an `httpEndPoint`, and a form pointing at a URL that does not
+        // exist looks completely correct until someone opens it.
+        const json = JSON.stringify(s.toJsonSchema(draftMemberSchemas[AllFormInputPrimaryKeys.MatOptions]));
+        expect(json).not.toContain('httpEndPoint');
+        expect(json).not.toContain('endpointId');
+        expect(json).toContain(DataSources.Local);
+        expect(json).toContain(DataSources.CustomOptions);
+    });
+    it('offers an api source once endpoints are supplied', () => {
+        const json = JSON.stringify(s.toJsonSchema(createMatOptionsSchema({
+            apiEndpoints: [{ id: 'abc123', name: 'Departments' }],
+        })));
+        expect(json).toContain('endpointId');
+        // The model selects a known id; it is never asked to author a URL.
+        expect(json).toContain('abc123');
+        expect(json).not.toContain('httpEndPoint');
+    });
+    it('takes the colSize bounds from the editor range control', () => {
+        const json = s.toJsonSchema(inputMemberSchemas[AllFormInputPrimaryKeys.ColSize]);
+        const bounds = json.properties.__wrappedPrimitive;
+        expect(bounds.minimum).toBe(1);
+        expect(bounds.maximum).toBe(12);
+    });
+    it('reaches the guidance inside secondary editors', () => {
+        // Rows nested in a `secondaryElementEditorConfig` were invisible to the
+        // derivation until it was taught to walk into them, and nothing failed to
+        // say so — the hints simply were not there. Both editors that exist today
+        // must be found, or that silent loss is back.
+        expect([...SECONDARY_GUIDED_PATHS.keys()].sort()).toEqual([
+            'mscoaConfig',
+            'workflowPickerConfig.presetFilters',
+        ]);
+        const filterPaths = SECONDARY_GUIDED_PATHS.get('workflowPickerConfig.presetFilters');
+        expect(filterPaths).toContain('valueSource');
+        expect(filterPaths).toContain('fromInputId');
+    });
+    it('derives the rows the settings panel shows on every element', () => {
+        // A `Default` row is rendered for every element and listed in no
+        // element's `properties`, so the members it edits were invisible to
+        // assembly. The derivation must find the ungated ones and leave the
+        // gated ones — `min` needs a numeric type, the rules need the flag — to
+        // the structural handling they already have.
+        expect(ALWAYS_SHOWN_MEMBERS).toContain(AllFormInputPrimaryKeys.Readonly);
+        expect(ALWAYS_SHOWN_MEMBERS).toContain(AllFormInputPrimaryKeys.OnlySetTempErrorOnTouch);
+        expect(ALWAYS_SHOWN_MEMBERS).toContain(AllFormInputPrimaryKeys.TourContent);
+        expect(ALWAYS_SHOWN_MEMBERS).toContain(AllFormInputPrimaryKeys.HintLabel);
+        expect(ALWAYS_SHOWN_MEMBERS).not.toContain(AllFormInputPrimaryKeys.Min);
+        expect(ALWAYS_SHOWN_MEMBERS).not.toContain(AllFormInputPrimaryKeys.IsCalculatedField);
+        expect(ALWAYS_SHOWN_MEMBERS).not.toContain(AllFormInputPrimaryKeys.CalculatedFieldRules);
+        // A nested binding belongs to the object that owns it, not to the column.
+        expect(ALWAYS_SHOWN_MEMBERS).not.toContain(AllFormInputPrimaryKeys.Script);
+    });
+    it('reads a negated applicability test as an exclusion', () => {
+        // `valueSource !== input` used to be rejected outright. Reading it as a
+        // POSITIVE rule would be worse than dropping it, so the polarity is what
+        // this pins down.
+        const fixed = describeIn('Base.', ['workflowPickerConfig', 'presetFilters'], 'value');
+        expect(fixed).toContain('valueSource is not input');
+        expect(fixed).not.toContain('valueSource is input.');
+        const bound = describeIn('Base.', ['workflowPickerConfig', 'presetFilters'], 'fromInputId');
+        expect(bound).toContain('valueSource is input');
+    });
+    it('keeps a secondary editor from leaking onto its opening path', () => {
+        // The mSCOA composite editor opens at `mscoaConfig` but edits dual-cash
+        // exclusion RULES, so prefixing its rows with the opening path would file
+        // `pattern` under `mscoaConfig.pattern` — a path nothing has. Guidance for
+        // it must be reachable through the nested lookup and nowhere else.
+        expect(SECONDARY_GUIDED_PATHS.get('mscoaConfig')).toContain('pattern');
+        expect(describeIn('Base.', ['mscoaConfig'], 'pattern')).not.toBe('Base.');
+    });
+    it('offers a validator as either a known name or a rule written inline', () => {
+        // The member is `Array<FormControlCustomValidatorsInterface | string>` and
+        // Joi mirrors it with `alternatives().try(string, object)`. Collapsing that
+        // to one branch is the failure this guards: only the object, and every
+        // built-in has to be rewritten by hand; only the string, and no
+        // form-specific rule can be expressed at all.
+        // The named branch exists only over names the caller supplied — with none,
+        // the item is the inline rule alone; see the house-rules spec.
+        // A schema whose root is not an object comes back wrapped, the same way
+        // the colSize bounds above are read.
+        const json = s.toJsonSchema(createValidatorsSchema({ namedValidators: [{ name: 'email' }] }));
+        const branches = json.properties.__wrappedPrimitive.items.anyOf.map((branch) => branch.type);
+        expect(branches).toContain('string');
+        expect(branches).toContain('object');
+    });
+    it('states every completion path against a member that exists', () => {
+        // `DRAFT_COMPLETION_REQUIRED` prefixes each module's entries with the column
+        // path they hang off, so a module has to start its own entries at the member
+        // it owns. `calculated-field` began at `variables[].id` instead of
+        // `calculatedFieldRules.variables[].id`, and the aggregate came out as
+        // `slides[].columns[].variables[].id` — a confident-looking path to nowhere,
+        // which is worse than an absent one for whoever writes the expansion.
+        const COLUMN = 'slides[].columns[].';
+        const known = new Set([
+            ...Object.values(AllFormInputPrimaryKeys),
+            ...Object.values(FormInputKeys),
+            ...Object.values(SpecialElementKeys),
+        ]);
+        const bad = DRAFT_COMPLETION_REQUIRED.filter((path) => path.startsWith(COLUMN))
+            .map((path) => path.slice(COLUMN.length).split(/[.[\s]/)[0])
+            .filter((member) => !known.has(member));
+        expect([...new Set(bad)]).toEqual([]);
+    });
+    it('never offers a document picker unless workflows were supplied', () => {
+        // Same reasoning as the api source above: `workflowId` is required, and a
+        // fabricated one produces a picker that looks right and resolves to
+        // nothing.
+        expect(createWorkflowPickerSchema()).toBeNull();
+        expect(createWorkflowPickerSchema({ workflows: [] })).toBeNull();
+        const offered = createWorkflowPickerSchema({
+            workflows: [{ id: 'wf-1', name: 'Purchase requisition' }],
+        });
+        expect(offered).not.toBeNull();
+        expect(JSON.stringify(s.toJsonSchema(offered))).toContain('wf-1');
+    });
+});

package/dist/skillet/tests/variant-assembly.spec.d.ts

@@ -0,0 +1 @@
+export {};