ngx-t-forms-types 0.0.30 → 0.0.34

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 {};