ng-form-foundry 0.3.1 → 0.3.3

package/README.md

@@ -90,6 +90,18 @@ this.form.getRawValue(); // full value, typed to the schema
 this.form.valid;         // validity from the schema's constraint validators
 ```
 
+If the schema contains `choice` nodes, `getRawValue()` carries their `__case`
+discriminators; `serializeForm(schema, form)` returns the value with them
+stripped — the inline wire encoding, which `buildFormFromSchema` accepts back
+as `initial` (the active case is re-inferred from which fields are present and
+required).
+
+Validity mirrors what would go on the wire: `presence` fields are absent until
+enabled and required while enabled (unless `nullable`), a `mandatory` or
+enabled-presence `choice` errors until a case is picked, and lists start empty
+rather than seeding a placeholder entry. A valid form serializes to a value
+that satisfies the schema's own constraints.
+
 ## Documentation
 
 Full guide, schema reference, and worked examples:

package/fesm2022/ng-form-foundry.mjs

@@ -55,12 +55,12 @@ function hasPresence(node) {
 }
 /**
  * Whether a presence child should start absent: there is no initial data
- * object, or its key is missing from it. A key that is present with an explicit
- * `null` value keeps its control — `null` is a value (a nullable leaf's), while
- * presence is about the *absent key*.
+ * object (a scalar seed counts as none), or its key is missing from it. A key
+ * that is present with an explicit `null` value keeps its control — `null` is
+ * a value (a nullable leaf's), while presence is about the *absent key*.
  */
 function presenceAbsent(initial, key) {
-    return initial == null || !(key in initial);
+    return initial == null || typeof initial !== 'object' || !(key in initial);
 }
 function enumValidator(choices) {
     const set = new Set(choices);
@@ -131,6 +131,14 @@ function buildLeafControl(leaf, initial) {
     const validators = [];
     if ('required' in leaf && leaf.required)
         validators.push(Validators.required);
+    // A presence leaf only ever has a control while enabled, and enabled means
+    // the key goes on the wire — an empty materialized value would serialize as
+    // null and fail typed-schema validation. So materialized ⇒ must hold a
+    // value; disable the field to omit it. A nullable presence leaf is exempt:
+    // explicit null is one of its legal values.
+    else if (leaf.presence === true && leaf.nullable !== true) {
+        validators.push(Validators.required);
+    }
     if ('type' in leaf && leaf.type === 'enum') {
         const choices = leaf.enum;
         validators.push(enumValidator(choices));
@@ -170,9 +178,11 @@ function buildLeafControl(leaf, initial) {
         validators,
     });
 }
+// The list value with no seed data is the empty array: a phantom null entry
+// would fail validation of the serialized value against typed item schemas,
+// and an empty list is the honest wire shape (renderers offer the add row).
 function buildLeafListControl(list, initial) {
-    const values = (Array.isArray(initial) ? initial : undefined) ??
-        list.default ?? [null];
+    const values = (Array.isArray(initial) ? initial : undefined) ?? list.default ?? [];
     return new FormArray(values.map((v) => new FormControl(v)));
 }
 function buildNodeGroupControl(group, initial) {
@@ -193,9 +203,10 @@ function buildNodeGroupControl(group, initial) {
     return new FormGroup(controls);
 }
 function buildNodeGroupListControl(list, initial = null) {
-    // `initial` is the runtime data array — one group per element. Fall back to a
-    // single empty group only when no initial data is supplied.
-    const values = Array.isArray(initial) ? initial : [null];
+    // `initial` is the runtime data array — one group per element. With no data
+    // the list is empty: seeding a phantom all-null group would put an invalid
+    // member on the wire (see buildLeafListControl).
+    const values = Array.isArray(initial) ? initial : [];
     return new FormArray(values.map((v) => buildNodeGroupControl(list.type, v)));
 }
 /**
@@ -219,9 +230,10 @@ function caseFields(body) {
 }
 /**
  * The active case of a choice: an explicit `__case` in the initial value, else
- * the case whose fields best match the initial data (inline wire data carries no
- * `__case`), else the schema `default`. This lets a choice seed from real
- * instance data whose branch is discriminated by which fields are present.
+ * the case {@link inferChoiceCase} ranks best against the initial data (inline
+ * wire data carries no `__case`), else the schema `default`. This lets a choice
+ * seed from real instance data whose branch is discriminated by which fields
+ * are present and required.
  */
 function resolveChoiceCase(choice, initial) {
     const explicit = initial?.[CASE_KEY];
@@ -229,29 +241,64 @@ function resolveChoiceCase(choice, initial) {
         return explicit;
     return inferChoiceCase(choice, initial) ?? choice.default;
 }
-/** Pick the case whose fields most overlap the initial data (none if nothing matches). */
+/**
+ * Pick the active case from inline wire data (which carries no `__case`).
+ *
+ * Candidates are the cases sharing at least one field name with the data; when
+ * none does, the caller falls back to the schema `default`. Candidates are
+ * ranked by, in order: fewest data keys the case has no field for (the case
+ * must be able to hold the data), fewest non-presence fields absent from the
+ * data (fields the form would have to materialize empty — this is how
+ * required-set-discriminated `oneOf` branches differ, e.g. a branch requiring
+ * `{ueId, qosId}` vs one requiring only `{qosId}`), most matched fields, and
+ * finally declaration order. Presence fields are exempt from the absence count
+ * because their absence is itself a legal state of the data.
+ */
 function inferChoiceCase(choice, initial) {
-    if (!initial)
+    if (initial == null || typeof initial !== 'object' || Array.isArray(initial))
         return undefined;
+    const dataKeys = new Set(Object.keys(initial).filter((k) => k !== CASE_KEY));
     let best;
-    let bestScore = 0;
+    let bestRank;
     for (const name of Object.keys(choice.cases)) {
-        const fields = Object.keys(caseFields(choice.cases[name]));
-        let score = 0;
-        for (const field of fields)
-            if (field in initial)
-                score++;
-        if (score > bestScore) {
-            bestScore = score;
+        const fields = caseFields(choice.cases[name]);
+        let matched = 0;
+        for (const key of dataKeys)
+            if (key in fields)
+                matched++;
+        if (matched === 0)
+            continue;
+        const missing = Object.keys(fields).filter((f) => !hasPresence(fields[f]) && !dataKeys.has(f)).length;
+        const rank = [dataKeys.size - matched, missing, -matched];
+        if (bestRank === undefined || lexLess(rank, bestRank)) {
+            bestRank = rank;
             best = name;
         }
     }
     return best;
 }
+/** Strictly-less comparison of two equal-length rank vectors, first difference wins. */
+function lexLess(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i];
+    }
+    return false;
+}
+/**
+ * Group error while a choice that must resolve to a case has none selected.
+ * Attached to `mandatory` choices (a case is always due) and `presence` choices
+ * (enabled means the key serializes, and `{}` satisfies no case) — a plain
+ * optional choice stays validator-free, `{ __case: null }` and all.
+ */
+function caseRequiredValidator() {
+    return (group) => group.get(CASE_KEY)?.value == null ? { caseRequired: true } : null;
+}
 /**
  * Build the FormGroup for a choice: a `__case` control holding the active case
  * name plus that case's field controls. Only the active case's fields are built,
- * matching the inline YANG encoding; switching the case swaps them.
+ * matching the inline YANG encoding; switching the case swaps them. Mandatory
+ * and presence choices carry {@link caseRequiredValidator}.
  */
 function buildChoiceControl(choice, initial) {
     const active = resolveChoiceCase(choice, initial);
@@ -266,7 +313,8 @@ function buildChoiceControl(choice, initial) {
             controls[key] = buildControl(caseChildren[key], initial?.[key]);
         }
     }
-    return new FormGroup(controls);
+    const needsCase = choice.mandatory === true || choice.presence === true;
+    return new FormGroup(controls, needsCase ? { validators: caseRequiredValidator() } : undefined);
 }
 /**
  * Switch a choice's FormGroup to `caseName`: sets `__case`, removes every other
@@ -469,6 +517,60 @@ function buildControl(node, initial) {
 function buildFormFromSchema(schema, initial = null) {
     return buildNodeGroupControl(schema, initial);
 }
+/**
+ * The wire value at `node`: `value` rebuilt with every choice discriminator
+ * removed.
+ *
+ * A choice's form value is `{ __case, ...fields }` ({@link CASE_KEY}); its wire
+ * encoding is the active case's fields inline, with no discriminator — the case
+ * is recovered from the field shape when the data is seeded back in
+ * ({@link resolveChoiceCase}). The walk is schema-driven: only positions the
+ * schema declares as choices are stripped, so a group child or map entry that
+ * happens to be named `__case` passes through untouched. Values at positions
+ * the schema does not describe pass through unchanged.
+ */
+function toWireValue(node, value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (isChoice(node)) {
+        const { [CASE_KEY]: active, ...rest } = value;
+        const fields = typeof active === 'string' && node.cases[active] ? caseFields(node.cases[active]) : {};
+        const out = {};
+        for (const key of Object.keys(rest)) {
+            out[key] = key in fields ? toWireValue(fields[key], rest[key]) : rest[key];
+        }
+        return out;
+    }
+    if (isNodeGroup(node)) {
+        const source = value;
+        const out = {};
+        for (const key of Object.keys(source)) {
+            out[key] = key in node.children ? toWireValue(node.children[key], source[key]) : source[key];
+        }
+        return out;
+    }
+    if (isNodeGroupList(node)) {
+        return Array.isArray(value) ? value.map((item) => toWireValue(node.type, item)) : value;
+    }
+    if (isMap(node)) {
+        const source = value;
+        const out = {};
+        for (const key of Object.keys(source))
+            out[key] = toWireValue(node.value, source[key]);
+        return out;
+    }
+    return value;
+}
+/**
+ * Serialize a form built by {@link buildFormFromSchema} to its wire value:
+ * `form.getRawValue()` with every choice's {@link CASE_KEY} discriminator
+ * stripped (see {@link toWireValue}). The result is the inline encoding that
+ * `buildFormFromSchema` accepts back as `initial`, so serialize → rebuild
+ * round-trips the value.
+ */
+function serializeForm(schema, form) {
+    return toWireValue(schema, form.getRawValue());
+}
 /**
  * Capture a schema literal with its exact type while checking it against
  * `NodeGroup`.
@@ -1617,5 +1719,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, NodeMapRendererComponent, addMapEntry, buildControl, buildFormFromSchema, caseFields, defineSchema, removeMapEntry, renameMapEntry, resolveChoiceCase, switchChoiceCase };
+export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, NodeMapRendererComponent, addMapEntry, buildControl, buildFormFromSchema, caseFields, defineSchema, removeMapEntry, renameMapEntry, resolveChoiceCase, serializeForm, switchChoiceCase, toWireValue };
 //# sourceMappingURL=ng-form-foundry.mjs.map