ng-form-foundry 0.3.3 → 0.3.5

package/index.d.ts

@@ -114,6 +114,14 @@ type NodeGroup = {
      */
     presence?: boolean;
     description?: string;
+    /**
+     * Minimum / maximum number of keys present in the group's value (JSON Schema
+     * `minProperties`/`maxProperties` on a closed object). Meaningful when
+     * children are presence-optional: the group carries a `minPresent` /
+     * `maxPresent` error while the count of enabled children is out of range.
+     */
+    minPresent?: number;
+    maxPresent?: number;
     children: Record<string, NodeType>;
     appearance?: Appearance;
 };
@@ -145,6 +153,8 @@ type NodeChoice = {
     /**
      * Display labels for cases, keyed by case name — for anonymous/auto-named
      * branches whose keys are not human-friendly. Falls back to the case name.
+     * Selectors render these through `caseDisplayLabels`, which disambiguates
+     * colliding entries by each case's distinguishing fields.
      */
     caseLabels?: Record<string, string>;
     default?: string;
@@ -204,6 +214,19 @@ type DFormGroup<T extends NodeGroup> = FormGroup<FormGroupType<T>>;
  * clobber the active-case control.
  */
 declare function caseFields(body: ChoiceCase): Record<string, NodeType>;
+/**
+ * Display labels for a choice's cases, keyed by case name, with colliding
+ * labels made unique. Schema-supplied `caseLabels` can repeat (e.g. two
+ * O-RAN A1 scope branches labeled from the same discriminating field), which
+ * makes the case selector ambiguous. Unique labels pass through untouched;
+ * each colliding case first gains the fields that set it apart from its
+ * same-labeled peers — "UE ID (Group ID)" vs "UE ID (Slice ID)" — and any
+ * cases the field suffix cannot separate (no distinguishing fields, peers
+ * with identical field sets among a larger clash group, or distinguishing
+ * fields that share one display label) fall back to their case name, which
+ * is unique by construction.
+ */
+declare function caseDisplayLabels(choice: NodeChoice): Record<string, string>;
 /**
  * The active case of a choice: an explicit `__case` in the initial value, else
  * the case {@link inferChoiceCase} ranks best against the initial data (inline
@@ -368,7 +391,11 @@ declare class DynamicRecursiveFormComponent implements OnInit {
     protected activeCase(key: string): string | null;
     /** A synthetic flattened NodeGroup used to render the active case's fields against the choice's FormGroup. */
     protected caseAsGroup(choice: NodeChoice, caseName: string): NodeGroup;
-    /** The display label for a case: the schema's `caseLabels` entry, else the case name. */
+    /**
+     * The display label for a case: the schema's `caseLabels` entry (colliding
+     * labels disambiguated by their distinguishing fields — see
+     * {@link caseDisplayLabels}), else the case name.
+     */
     caseLabel(choice: NodeChoice, caseName: string): string;
     /**
      * A copy of a group flagged to render its fields inline (no inner panel). Used
@@ -414,6 +441,10 @@ interface DetailSection {
     schema: NodeGroup | null;
     /** The group `schema` binds to (the node's group; for a choice, the choice group). */
     group: FormGroup | null;
+    /** A trailing add-control section of a list / complex map: renders after the last item, with no heading. */
+    footer?: boolean;
+    /** The section continues a run of same-list items / same-map entries: its heading draws no divider line. */
+    continuation?: boolean;
 }
 /**
  * A navigable node in the config tree. Its `id` is the node's stable path from
@@ -486,8 +517,12 @@ declare class ConfigEditorComponent implements OnDestroy {
     readonly schema: _angular_core.InputSignal<NodeGroup>;
     /** The schema-built reactive group the editor binds to and mutates. */
     readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
-    /** Whether fields accept input and structural controls (add/remove/menus) show. */
-    readonly editable: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether fields accept input and structural controls (add/remove/menus)
+     * show. Two-way bindable: the root tree row carries a toggle, so the editor
+     * can flip it itself and the host observes the change.
+     */
+    readonly editable: _angular_core.ModelSignal<boolean>;
     root: TreeNode;
     selected: TreeNode | null;
     /** The selected subtree as a flat, breadcrumb-separated section list. */
@@ -522,15 +557,20 @@ declare class ConfigEditorComponent implements OnDestroy {
      * descendants, so an error anywhere below lights every ancestor row.
      */
     protected hasError(node: TreeNode): boolean;
-    /** Append a new item to a list node's FormArray (up to `maxItems`), then select it. */
-    addItem(listNode: TreeNode): void;
+    /**
+     * Append a new item to a list node's FormArray (up to `maxItems`). A tree-row
+     * add selects the new item; a detail-pane add passes `keepSelection` so the
+     * current (possibly ancestor) view stays put and the item appears as a new
+     * section in it.
+     */
+    addItem(listNode: TreeNode, keepSelection?: boolean): void;
     /**
      * Remove a list item from its FormArray (down to `minItems`). List-item
      * identity is positional, so expansion state under the list is cleared —
      * otherwise it would silently migrate to the items that shift into the
      * removed indexes.
      */
-    removeItem(listNode: TreeNode, item: TreeNode): void;
+    removeItem(listNode: TreeNode, item: TreeNode, keepSelection?: boolean): void;
     /** The just-added optional leaf (section path + key) whose field grabs focus when rendered. */
     protected focusSectionId: string | null;
     protected focusLeafKey: string | null;
@@ -542,25 +582,46 @@ declare class ConfigEditorComponent implements OnDestroy {
     activeCase(node: TreeNode): string | null;
     /** The display label of a choice node's active case, or null when no case is selected. */
     activeCaseLabel(node: TreeNode): string | null;
-    /** The display label for a case: the schema's `caseLabels` entry, else the case name. */
+    /**
+     * The display label for a case: the schema's `caseLabels` entry (colliding
+     * labels disambiguated by their distinguishing fields — see
+     * {@link caseDisplayLabels}), else the case name.
+     */
     protected caseLabel(choice: NodeChoice, caseName: string): string;
-    /** Switch a choice node's active case; the structural sync rebuilds the tree and sections. */
+    /**
+     * Switch a choice node's active case from its detail selector; the
+     * structural sync rebuilds the tree and sections. The tree selection stays
+     * where it is: detail edits must never steal it, or a flattened ancestor
+     * view would collapse to the choice node mid-edit. Selection moves only
+     * through the tree itself.
+     */
     switchTreeCase(node: TreeNode, caseName: string): void;
     protected objectKeys(obj: Record<string, unknown>): string[];
-    /** Append a new entry to a complex map node under a generated unique key, then select it. */
-    addTreeMapEntry(mapNode: TreeNode): void;
+    /**
+     * Append a new entry to a complex map node under a generated unique key. A
+     * tree-row add selects the new entry; a detail-pane add passes
+     * `keepSelection` so the current view stays put (see {@link addItem}).
+     */
+    addTreeMapEntry(mapNode: TreeNode, keepSelection?: boolean): void;
     /** Remove a complex map entry (down to `minEntries`). */
-    removeTreeMapEntry(mapNode: TreeNode, entryNode: TreeNode): void;
+    removeTreeMapEntry(mapNode: TreeNode, entryNode: TreeNode, keepSelection?: boolean): void;
     /**
-     * Commit a rename-on-blur of a map entry's key; on success the entry is
-     * selected under its new path and its fresh key field regains focus (the
-     * rename re-renders the section under a new id, destroying the input that
-     * held focus).
+     * Commit a rename-on-blur of a map entry's key; on success the selection is
+     * remapped to the entry's new identity when it pointed at (or inside) the
+     * entry — otherwise it stays put — and the fresh key field regains focus
+     * (the rename re-renders the section under a new id, destroying the input
+     * that held focus).
      */
     renameTreeMapEntry(entryNode: TreeNode, rawKey: string): void;
     /** Move keyboard focus to the selected tree row once the action's re-render settles. */
     private focusSelectedRow;
     /** A muted hint for a section whose node currently renders no content of its own. */
+    /**
+     * Explains a group's `minPresent`/`maxPresent` violation next to the red
+     * tree marker: the fix is enabling or removing optional fields, which is not
+     * evident from any single field's own error.
+     */
+    protected presentRangeHint(s: DetailSection): string | null;
     protected emptySectionHint(s: DetailSection): string | null;
     /** Whether a list node is at `maxItems` (the add control is hidden). */
     protected listAtMax(node: TreeNode | undefined): boolean;
@@ -596,6 +657,31 @@ declare class ConfigEditorComponent implements OnDestroy {
      * chrome — the headings are the boundaries between children.
      */
     private buildSections;
+    /**
+     * Whether a section renders anything beyond its heading: a leaf slice, the
+     * chrome of its node kind (case selector, key field, add controls), or a
+     * present-children error that needs explaining. Heading-only sections are
+     * dropped from the flat list — a divider with nothing under it is clutter.
+     */
+    private sectionHasContent;
+    /** Every expandable node currently expanded — drives the root row's expand/collapse-all toggle. */
+    protected allExpanded(): boolean;
+    /**
+     * Expand every expandable node, or collapse back when all are open. The
+     * collapse keeps the root open — a tree reduced to one row reads as empty.
+     */
+    protected toggleExpandAll(): void;
+    /** The selected member's container (list / map), for the breadcrumb's remove control. */
+    protected selectedMemberParent(): TreeNode | null;
+    /** The section node's container (list / map), for member controls in its heading. */
+    protected memberParent(s: DetailSection): TreeNode | null;
+    /**
+     * Flag the sections that continue a run of siblings — a list item or map
+     * entry whose preceding section is inside the same container. Their headings
+     * draw no divider line, so a run of same-kind members reads as one list
+     * rather than a stack of separated blocks.
+     */
+    private markContinuations;
     /** A section's own renderable fields: a leaf-only schema slice and the group it binds to. */
     private sectionContent;
     /**
@@ -620,7 +706,7 @@ declare class ConfigEditorComponent implements OnDestroy {
      */
     private escapeSeg;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfigEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfigEditorComponent, "nff-config-editor", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfigEditorComponent, "nff-config-editor", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, { "editable": "editableChange"; }, never, never, true, never>;
 }
 
 declare class LeafRendererComponent implements AfterViewInit {
@@ -737,5 +823,5 @@ declare class NodeMapRendererComponent implements OnChanges {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NodeMapRendererComponent, "nff-node-map-renderer", never, { "nodeMap": { "alias": "nodeMap"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, NodeMapRendererComponent, addMapEntry, buildControl, buildFormFromSchema, caseFields, defineSchema, removeMapEntry, renameMapEntry, resolveChoiceCase, serializeForm, switchChoiceCase, toWireValue };
+export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, NodeMapRendererComponent, addMapEntry, buildControl, buildFormFromSchema, caseDisplayLabels, caseFields, defineSchema, removeMapEntry, renameMapEntry, resolveChoiceCase, serializeForm, switchChoiceCase, toWireValue };
 export type { AnonLeaf, Appearance, ChoiceCase, DFormControl, DFormGroup, FormGroupType, Leaf, LeafBase, LeafBoolean, LeafEnum, LeafList, LeafNumber, LeafRuntimeType, LeafString, NodeChoice, NodeGroup, NodeGroupList, NodeMap, NodeType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-form-foundry",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Build fully-typed Angular Reactive Forms and Angular Material UI from a declarative, recursive form-description schema.",
   "keywords": [
     "angular",