ng-form-foundry 0.2.1 → 0.3.0

package/index.d.ts

@@ -1,6 +1,6 @@
 import { FormControl, FormArray, FormGroup } from '@angular/forms';
 import * as i0 from '@angular/core';
-import { OnInit, EventEmitter, AfterViewInit, QueryList, ChangeDetectorRef } from '@angular/core';
+import { OnInit, AfterViewInit, EventEmitter, ElementRef, QueryList, ChangeDetectorRef } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
 
 type LeafRuntimeType<T> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'enum' ? string | number : never;
@@ -10,6 +10,26 @@ type LeafBase = {
     required?: true | undefined;
     label?: string;
     description?: string;
+    /**
+     * The value may be `null` (JSON Schema `type: [T, 'null']`). Builds a nullable
+     * control (drops `nonNullable`), so `null` is a first-class value the
+     * constraint validators accept and that survives the round-trip. Distinct from
+     * {@link presence}: `nullable` is an explicit `null`, `presence` is an absent key.
+     */
+    nullable?: boolean;
+    /**
+     * Optional scalar whose *presence itself* is data (mirrors {@link NodeGroup.presence}).
+     * Rendered with an on/off toggle; the control is removed from the parent group
+     * when absent (so it drops from `form.value`) and re-added when toggled on. The
+     * builder omits it unless an initial value is supplied.
+     */
+    presence?: boolean;
+    /**
+     * Render the field read-only even when the surrounding form is editable.
+     * Combine with `default` to express a JSON Schema `const` (a fixed,
+     * display-only value); single-element `enum` is the alternative for a constant.
+     */
+    readOnly?: boolean;
 };
 type AnonLeaf = {
     [K in Leaf['type']]: {
@@ -19,10 +39,30 @@ type AnonLeaf = {
 type LeafString = LeafBase & {
     type: 'string';
     default?: LeafRuntimeType<'string'>;
+    /**
+     * Reject values that don't match this regular expression. Follows JSON Schema
+     * `pattern` semantics — an *unanchored* `RegExp.test`, so it matches anywhere
+     * in the value unless the pattern itself anchors with `^`/`$`.
+     */
+    pattern?: string;
+    /** Minimum string length (JSON Schema `minLength`). */
+    minLength?: number;
+    /** Maximum string length (JSON Schema `maxLength`). */
+    maxLength?: number;
+    /** Semantic string format (JSON Schema `format`); adds a matching validator. */
+    format?: 'email' | 'uri' | 'url';
 };
 type LeafNumber = LeafBase & {
     type: 'number';
     default?: LeafRuntimeType<'number'>;
+    /** Require a whole-number value (JSON Schema `type: 'integer'`). */
+    integer?: boolean;
+    /** Inclusive lower bound (JSON Schema `minimum`). */
+    min?: number;
+    /** Inclusive upper bound (JSON Schema `maximum`). */
+    max?: number;
+    /** Require the value to be an integer multiple of this number (JSON Schema `multipleOf`). */
+    multipleOf?: number;
 };
 type LeafBoolean = LeafBase & {
     type: 'boolean';
@@ -37,6 +77,8 @@ type LeafEnum = LeafBase & {
 type Appearance = {
     flatten?: boolean;
     noBorder?: boolean;
+    /** Start this node's section panel collapsed. Ignored when `flatten` is set. */
+    collapsed?: boolean;
 };
 type Leaf = LeafString | LeafNumber | LeafBoolean | LeafEnum;
 type LeafList<TKind extends Leaf['type'] = Leaf['type']> = {
@@ -75,29 +117,132 @@ type NodeGroup = {
     children: Record<string, NodeType>;
     appearance?: Appearance;
 };
+/**
+ * One case of a {@link NodeChoice}: either a record of named fields (an object
+ * branch), or a single node (a *leaf-bodied* case — e.g. an `anyOf` branch that
+ * is a bare scalar). A single node is normalized to a one-field record keyed by
+ * its `name` when the form is built.
+ */
+type ChoiceCase = Record<string, NodeType> | NodeType;
 /**
  * A discriminated selection: the user picks one `case`, and only that case's
  * fields are present. In the form it is a FormGroup holding a `__case` control
  * (the active case name) plus that case's field controls; switching the case
  * swaps the field controls.
+ *
+ * Cases may be **anonymous / auto-named** (any string key) — for JSON Schema
+ * `anyOf`/`oneOf` branches with no name. When a built form is seeded from inline
+ * data that carries no `__case`, the builder **infers** the active case from the
+ * data shape (the case whose fields best match), so a choice round-trips from
+ * real instance data. See the schema reference for the required-set / `const`
+ * discriminator recipe.
  */
 type NodeChoice = {
     kind: 'choice';
     name: string;
     label?: string;
-    cases: Record<string, Record<string, NodeType>>;
+    cases: Record<string, ChoiceCase>;
+    /**
+     * 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.
+     */
+    caseLabels?: Record<string, string>;
     default?: string;
     mandatory?: boolean;
+    /** Optional choice: rendered with an on/off toggle, omitted from the value when absent. */
+    presence?: boolean;
+    appearance?: Appearance;
 };
 /** The control name that records which case of a {@link NodeChoice} is active. */
 declare const CASE_KEY = "__case";
-type NodeType = Leaf | LeafList | NodeGroup | NodeGroupList | NodeChoice;
-type DFormControl<T extends NodeType> = T extends Leaf ? FormControl<LeafRuntimeType<T['type']>> : T extends LeafList ? FormArray<FormControl<LeafRuntimeType<T['type']>>> : T extends NodeGroup ? DFormGroup<T> : T extends NodeGroupList ? FormArray<DFormGroup<T['type']>> : T extends NodeChoice ? FormGroup<any> : never;
+/**
+ * An open, arbitrary-keyed record: unlike {@link NodeGroup} (a fixed, declared
+ * key set), a map's keys are runtime data and every value conforms to one shared
+ * `value` schema. Maps JSON Schema `additionalProperties: <schema>` /
+ * `patternProperties`. In the form it is a `FormGroup` whose control *names* are
+ * the entry keys, so `getRawValue()` is the map object directly; the renderer
+ * lets the user add, remove, and rename entries.
+ */
+type NodeMap = {
+    kind: 'map';
+    name: string;
+    label?: string;
+    description?: string;
+    /** The schema every entry's value conforms to. */
+    value: NodeType;
+    /** Label for the key column in the editor. Defaults to "Key". */
+    keyLabel?: string;
+    /** `patternProperties`: entry keys must match this regular expression. */
+    keyPattern?: string;
+    /** Minimum number of entries (JSON Schema `minProperties`). */
+    minEntries?: number;
+    /** Maximum number of entries (JSON Schema `maxProperties`). */
+    maxEntries?: number;
+    /** Optional map: rendered with an on/off toggle, omitted from the value when absent. */
+    presence?: boolean;
+    appearance?: Appearance;
+};
+type NodeType = Leaf | LeafList | NodeGroup | NodeGroupList | NodeChoice | NodeMap;
+type DFormControl<T extends NodeType> = T extends Leaf ? FormControl<LeafRuntimeType<T['type']>> : T extends LeafList ? FormArray<FormControl<LeafRuntimeType<T['type']>>> : T extends NodeGroup ? DFormGroup<T> : T extends NodeGroupList ? FormArray<DFormGroup<T['type']>> : T extends NodeChoice ? FormGroup<any> : T extends NodeMap ? FormGroup<any> : never;
 type FormGroupType<T extends NodeGroup> = {
     [TChild in keyof T['children']]: DFormControl<T['children'][TChild]>;
 };
 type DFormGroup<T extends NodeGroup> = FormGroup<FormGroupType<T>>;
 
+/**
+ * Build the `AbstractControl` for a single schema node.
+ *
+ * Dispatches on `node.kind`: a `leaf` becomes a `FormControl`, a `leafList` a
+ * `FormArray` of controls, a `nodeGroup` a nested `FormGroup`, and a
+ * `nodeGroupList` a `FormArray` of groups. `initial` is the runtime value for
+ * this node — a scalar for a leaf, an array for a list, an object for a group —
+ * and seeds the control's value (falling back to the node's `default`).
+ *
+ * Most callers use {@link buildFormFromSchema}; this is exposed for building a
+ * control from a single non-root node.
+ */
+/**
+ * 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.
+ */
+/**
+ * Normalize a {@link ChoiceCase} to a field record. A field record is returned
+ * as-is; a single node (a leaf-bodied case, e.g. a scalar `anyOf` branch) becomes
+ * a one-field record keyed by the node's `name`. The discriminant is a top-level
+ * `kind` string, which a field record never has (its keys are field names).
+ */
+declare function caseFields(body: ChoiceCase): Record<string, NodeType>;
+/**
+ * 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.
+ */
+declare function resolveChoiceCase(choice: NodeChoice, initial?: Record<string, unknown> | null): string | undefined;
+/**
+ * Switch a choice's FormGroup to `caseName`: sets `__case`, removes every other
+ * control, and builds `caseName`'s fields (normalized via {@link caseFields})
+ * with their defaults. An unknown case name leaves only `__case`.
+ */
+declare function switchChoiceCase(group: FormGroup, choice: NodeChoice, caseName: string): void;
+/**
+ * Append a map entry built from `map.value` and return its committed key, or
+ * `null` when nothing was added. With no `key`, the first free `keyN`
+ * placeholder is generated (not checked against `keyPattern` — placeholders are
+ * meant to be renamed). An explicit `key` is rejected when it duplicates an
+ * existing entry or violates `keyPattern`. Rejects when `maxEntries` is reached.
+ */
+declare function addMapEntry(group: FormGroup, map: NodeMap, key?: string): string | null;
+/**
+ * Rename entry `oldKey` to `newKey.trim()`, preserving the control instance
+ * (remove + re-add, so the value survives). Returns whether the rename was
+ * committed: an empty, unchanged, duplicate, or `keyPattern`-violating key is a
+ * no-op, leaving the entry under its current name.
+ */
+declare function renameMapEntry(group: FormGroup, map: NodeMap, oldKey: string, newKey: string): boolean;
+/** Remove entry `key` unless the map is at `minEntries`. Returns whether it was removed. */
+declare function removeMapEntry(group: FormGroup, map: NodeMap, key: string): boolean;
 declare function buildControl<T extends NodeType>(node: T, initial?: unknown | null): DFormControl<T> | FormControl<LeafRuntimeType<any>> | FormArray<any>;
 declare function buildFormFromSchema<S extends NodeGroup>(schema: S, initial?: Record<string, unknown> | null): DFormGroup<S>;
 /**
@@ -120,16 +265,26 @@ declare function asFormArray(control: any): FormArray;
 declare function asFormGroup(control: any): FormGroup;
 
 declare class DynamicRecursiveFormComponent implements OnInit {
-    schema: NodeGroup;
-    initialValue: any;
-    formGroup: FormGroup<any>;
-    index: number | null;
-    removable: boolean;
-    remove: EventEmitter<any>;
-    title: string;
-    editable: boolean;
-    addButtonCallback: ((index: number) => void) | null;
-    root: boolean;
+    /** The form-description schema to render (a root or nested `NodeGroup`). */
+    readonly schema: i0.InputSignal<NodeGroup>;
+    /** Optional value object to seed the form; keyed by the schema's `children` keys. */
+    readonly initialValue: i0.InputSignal<Record<string, unknown> | null>;
+    /** The reactive group this form binds to. Defaults to an empty group. */
+    readonly formGroup: i0.InputSignal<FormGroup<any>>;
+    /** Index of this form within a parent list, used by `addButtonCallback`. */
+    readonly index: i0.InputSignal<number | null>;
+    /** Whether this form may be removed from a parent list (shows a remove control). */
+    readonly removable: i0.InputSignal<boolean>;
+    /** Emitted when the user removes this form from a parent list. */
+    readonly remove: i0.OutputEmitterRef<void>;
+    /** Card/section title; falls back to the schema label or name. */
+    readonly title: i0.InputSignal<string | undefined>;
+    /** Whether fields accept input. Two-way: also toggled by the built-in edit control. */
+    readonly editable: i0.ModelSignal<boolean>;
+    /** Invoked with {@link index} to append a new sibling form to a parent list. */
+    readonly addButtonCallback: i0.InputSignal<((index: number) => void) | null>;
+    /** True when the schema is a root group (rendered flat, without a wrapping card). */
+    readonly root: i0.Signal<boolean>;
     ngOnInit(): void;
     get nodeGroupChildrenList(): Array<{
         key: string;
@@ -141,19 +296,41 @@ declare class DynamicRecursiveFormComponent implements OnInit {
      * group from `form.value`; adding it rebuilds the sub-group from its schema.
      */
     togglePresence(key: string, schema: NodeGroup, present: boolean): void;
+    /** The key of the presence leaf the user just enabled; its field grabs focus when rendered. */
+    protected presenceFocusKey: string | null;
+    /**
+     * Add or remove a presence leaf's control on this form. Removing it drops the
+     * leaf from `form.value`; adding it rebuilds the control from its schema and
+     * focuses the rendered field.
+     */
+    toggleLeafPresence(key: string, schema: Leaf, present: boolean): void;
+    /**
+     * Add or remove a presence map's or choice's control on this form. Removing it
+     * drops the node from `form.value`; adding it rebuilds the control (an empty
+     * map, or a choice group holding `__case`) from its schema.
+     */
+    toggleNodePresence(key: string, schema: NodeType, present: boolean): void;
     protected readonly CASE_KEY = "__case";
     objectKeys(obj: Record<string, unknown>): string[];
     /** The active case name of a choice control, or null if none is selected. */
     activeCase(key: string): string | null;
     /** A synthetic flattened NodeGroup used to render the active case's fields against the choice's FormGroup. */
     caseAsGroup(choice: NodeChoice, caseName: string): NodeGroup;
-    /** Swap a choice's field controls when the selected case changes. */
+    /** The display label for a case: the schema's `caseLabels` entry, 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
+     * for a presence group's body, whose container is the presence panel itself, so
+     * the group's own section panel would be a redundant second box.
+     */
+    flatGroup(group: NodeGroup): NodeGroup;
+    /** Swap a choice's field controls when the selected case changes. Delegates to {@link switchChoiceCase}. */
     switchCase(key: string, choice: NodeChoice, caseName: string): void;
     protected readonly asFormGroup: typeof asFormGroup;
     protected readonly asFormArray: typeof asFormArray;
     protected readonly asFormControl: typeof asFormControl;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicRecursiveFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicRecursiveFormComponent, "nff-dynamic-recursive-form", never, { "schema": { "alias": "schema"; "required": true; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "index": { "alias": "index"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "title": { "alias": "title"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "addButtonCallback": { "alias": "addButtonCallback"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicRecursiveFormComponent, "nff-dynamic-recursive-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "addButtonCallback": { "alias": "addButtonCallback"; "required": false; "isSignal": true; }; }, { "remove": "remove"; "editable": "editableChange"; }, never, never, true, never>;
 }
 
 /** Metadata on a list-container node that lets the tree add items to its FormArray. */
@@ -163,21 +340,30 @@ interface ListRef {
     itemLabel: string;
     minItems: number;
 }
+/** An absent optional (presence) child, offered by its parent node's "+ Optional field" menu. */
+interface OptionalEntry {
+    key: string;
+    schema: NodeType;
+    label: string;
+    /** Index in the parent schema's children iteration; keeps the menu in schema order. */
+    order: number;
+}
 /** A navigable node in the config tree. Groups and list items are tree nodes; leaves are their detail. */
 interface TreeNode {
     id: string;
     label: string;
     children: TreeNode[];
-    /** Leaves editable when this node is selected. Empty for list-container nodes. */
+    /** Leaves editable when this node is selected. A presence leaf carries its `optional` entry so it can be removed back to the menu. */
     leaves: {
         key: string;
         node: Leaf;
+        optional?: OptionalEntry;
     }[];
     leafLists: {
         key: string;
         node: LeafList;
     }[];
-    /** The FormGroup holding this node's leaves, or null for a list-container node. */
+    /** The FormGroup holding this node's leaves, or null for a list-container or map node. */
     group: FormGroup | null;
     /** Present on a nodeGroupList node: lets a `+` add an item. */
     list?: ListRef;
@@ -186,26 +372,51 @@ interface TreeNode {
         array: FormArray;
         index: number;
     };
-    /** Present on an optional (presence) group node: lets a checkbox add/remove the group. */
-    presence?: {
-        parentGroup: FormGroup;
+    /** Absent optional children of this node, offered by its "+ Optional field" menu. */
+    optionals?: OptionalEntry[];
+    /** Present on a present optional child node: drives the row's remove control; removal returns `entry` to the parent's menu. */
+    presenceRemovable?: {
+        entry: OptionalEntry;
+    };
+    /** Present on a choice node: the choice schema and its FormGroup (holding `__case` + the active case's fields). */
+    choice?: {
+        schema: NodeChoice;
+        group: FormGroup;
+    };
+    /** Present on a map node. `complex` maps expand entries as child nodes; leaf-valued maps edit inline in the detail pane. */
+    map?: {
+        schema: NodeMap;
+        group: FormGroup;
+        complex: boolean;
+    };
+    /** Present on a complex-map entry node: addresses the entry in its map for remove/rename. */
+    mapEntry?: {
+        mapGroup: FormGroup;
+        mapSchema: NodeMap;
         key: string;
-        schema: NodeGroup;
     };
-    /** For a presence node: whether the group is currently present. */
-    present?: boolean;
 }
 /**
- * A tree/detail editor for a schema-built form: the structure (containers, lists,
- * groups) is a tree on the left, and selecting a node shows that node's leaf
- * fields for editing on the right. A `+` on a list node adds an entry; a delete
- * button on each item removes it. An alternative to the all-in-one
- * {@link DynamicRecursiveFormComponent} for large configs.
+ * A tree/detail editor for a schema-built form: the structure (groups, lists,
+ * maps, choices) is a tree on the left, and selecting a node shows that node's
+ * fields for editing on the right. A `+` on a list or map node adds an entry; a
+ * delete button on each item removes it. Absent optional (presence) children are
+ * offered by a "+ Optional field" menu row at the end of their parent's
+ * children; present ones carry a delete button that returns them to the menu.
+ *
+ * The component draws no outer container — only a divider between the tree and
+ * detail panes — so the embedding client owns the surrounding chrome. The tree
+ * is built once from the `schema`/`formGroup` provided at initialization.
+ * An alternative to the all-in-one {@link DynamicRecursiveFormComponent} for
+ * large configs.
  */
 declare class ConfigEditorComponent implements OnInit {
-    schema: NodeGroup;
-    formGroup: FormGroup;
-    editable: boolean;
+    /** The form-description schema whose structure the tree renders. */
+    readonly schema: i0.InputSignal<NodeGroup>;
+    /** The schema-built reactive group the editor binds to and mutates. */
+    readonly formGroup: i0.InputSignal<FormGroup<any>>;
+    /** Whether fields accept input and structural controls (add/remove/menus) show. */
+    readonly editable: i0.InputSignal<boolean>;
     root: TreeNode;
     selected: TreeNode | null;
     readonly expanded: Set<string>;
@@ -221,32 +432,92 @@ declare class ConfigEditorComponent implements OnInit {
      */
     pathTo(target: TreeNode): TreeNode[];
     toggle(node: TreeNode): void;
+    /** Whether the row shows an expand twisty: it has child rows to reveal (children or an optionals menu row). */
+    hasExpandableContent(node: TreeNode): boolean;
+    /**
+     * Whether the node's form subtree holds a validation error. Group/choice, list,
+     * and map nodes each check their backing control; `invalid` aggregates over
+     * descendants, so an error anywhere below lights every ancestor row.
+     */
+    hasError(node: TreeNode): boolean;
     /** Append a new item to a list node's FormArray and to the tree, then select it. */
     addItem(listNode: TreeNode): void;
     /** Remove a list item from its FormArray and the tree (down to `minItems`). */
     removeItem(listNode: TreeNode, item: TreeNode): void;
-    /** Enable or disable an optional (presence) group by adding/removing its control. */
-    setPresence(node: TreeNode, present: boolean): void;
+    /** The key of the optional leaf the user just added; its detail-pane field grabs focus when rendered. */
+    protected focusLeafKey: string | null;
+    /** Add an absent optional child from the menu: build its control, place it in the tree, and select it. */
+    addOptional(node: TreeNode, entry: OptionalEntry): void;
+    /** Remove a present optional child node, returning its entry to the parent's menu. */
+    removeOptional(parent: TreeNode, node: TreeNode): void;
+    /** Remove a present optional leaf from the detail pane, returning its entry to the menu. */
+    removeOptionalLeaf(node: TreeNode, leaf: {
+        key: string;
+        node: Leaf;
+        optional?: OptionalEntry;
+    }): void;
+    /** The active case name of a choice node, or null when none is selected. */
+    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. */
+    caseLabel(choice: NodeChoice, caseName: string): string;
+    /** Switch a choice node's active case: swap the group's controls and rebuild the subtree in place. */
+    switchTreeCase(node: TreeNode, caseName: string): void;
+    /** Append a new entry to a complex map node under a generated unique key, then select it. */
+    addTreeMapEntry(mapNode: TreeNode): void;
+    /** Remove a complex map entry (down to `minEntries`) from the form group and the tree. */
+    removeTreeMapEntry(mapNode: TreeNode, entryNode: TreeNode): void;
+    /** Commit a rename-on-blur of a map entry's key; on success the node is relabeled. */
+    renameTreeMapEntry(entryNode: TreeNode, rawKey: string): void;
+    /** Whether a map node is at `maxEntries` (the add control is hidden). */
+    mapAtMax(node: TreeNode | undefined): boolean;
+    /** Whether a map node is at `minEntries` (entry remove controls are hidden). */
+    mapAtMin(node: TreeNode | undefined): boolean;
     protected readonly asFormControl: typeof asFormControl;
     protected readonly asFormArray: typeof asFormArray;
-    private placeholder;
+    protected readonly CASE_KEY = "__case";
+    objectKeys(obj: Record<string, unknown>): string[];
     /** Re-index and re-label a list node's item children (just "#n") after add/remove. */
     private renumber;
+    /** Select `fallback` when the current selection is no longer reachable in the tree. */
+    private reselectIfOrphaned;
+    /** Re-insert a removed optional's entry into the node's menu, keeping schema order. */
+    private reinsertOptional;
+    /** Synthetic group over a case's normalized fields, so a case body builds like any group. */
+    private caseAsGroup;
     private buildTree;
+    /** Build the tree node for a single non-leaf child, dispatching on its kind. Null when its control is missing. */
+    private buildChildNode;
+    /** A node's display label: its schema `label`, else its record key. */
+    private labelOf;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigEditorComponent, "nff-config-editor", never, { "schema": { "alias": "schema"; "required": true; }; "formGroup": { "alias": "formGroup"; "required": true; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵ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>;
 }
 
-declare class LeafRendererComponent implements OnInit {
+declare class LeafRendererComponent implements OnInit, AfterViewInit {
+    private readonly elementRef;
     leaf_: Leaf | AnonLeaf;
     control: FormControl;
     initialValue?: any;
     removable: boolean;
     editable: boolean;
+    /** Focus the field once rendered — for fields the user just added (e.g. an enabled presence leaf). */
+    autofocus: boolean;
     remove: EventEmitter<number>;
+    constructor(elementRef: ElementRef<HTMLElement>);
     ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /** Whether this field accepts input: the form is editable and the leaf is not `readOnly`. */
+    get fieldEditable(): boolean;
+    /**
+     * A human-readable message for the control's active validation error, or `''`
+     * when valid. `mat-form-field` only shows it once the field is in an error
+     * state (invalid and touched), so it can be bound unconditionally.
+     */
+    get errorText(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<LeafRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LeafRendererComponent, "nff-leaf-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "control": { "alias": "control"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LeafRendererComponent, "nff-leaf-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "control": { "alias": "control"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
 }
 
 declare class LeafListRendererComponent implements OnInit {
@@ -303,5 +574,41 @@ declare class NodeGroupListRendererComponent implements OnInit, AfterViewInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<NodeGroupListRendererComponent, "nff-node-group-list-renderer", never, { "nodeGroupList": { "alias": "nodeGroupList"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "minItems": { "alias": "minItems"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; }, { "message": "message"; }, never, never, true, never>;
 }
 
-export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, buildControl, buildFormFromSchema, defineSchema };
-export type { AnonLeaf, Appearance, DFormControl, DFormGroup, FormGroupType, Leaf, LeafBase, LeafBoolean, LeafEnum, LeafList, LeafNumber, LeafRuntimeType, LeafString, NodeChoice, NodeGroup, NodeGroupList, NodeType };
+/**
+ * Renders a {@link NodeMap}: an open, arbitrary-keyed record. Each entry is a row
+ * with an editable key and the shared value schema's control; the user can add,
+ * remove, and rename entries. The map's control is a `FormGroup` whose control
+ * names are the entry keys, so the key is edited as a *rename* (remove + re-add
+ * the same control) committed on blur — see {@link renameEntry}.
+ */
+declare class NodeMapRendererComponent implements OnInit {
+    nodeMap: NodeMap;
+    formGroup: FormGroup<any>;
+    editable: boolean;
+    /** Ordered view of entry keys, kept stable across renames (`addControl` appends). */
+    entryKeys: string[];
+    ngOnInit(): void;
+    /** The value schema as a leaf (used when `value.kind === 'leaf'`). */
+    get valueLeaf(): Leaf;
+    /** The value schema as a group (used when `value.kind === 'nodeGroup'`). */
+    get valueGroup(): NodeGroup;
+    get atMax(): boolean;
+    get atMin(): boolean;
+    /** Append a new entry under a unique placeholder key. Delegates to {@link addMapEntry}. */
+    addEntry(): void;
+    /** Drop an entry (its control leaves the group, so it drops from the value). Delegates to {@link removeMapEntry}. */
+    removeEntry(key: string): void;
+    /**
+     * Commit an edited key by renaming its control once (the value is preserved).
+     * An empty, unchanged, duplicate, or `keyPattern`-violating key is a no-op,
+     * leaving the entry under its current name. Delegates to {@link renameMapEntry}.
+     */
+    renameEntry(oldKey: string, rawKey: string): void;
+    protected readonly asFormControl: typeof asFormControl;
+    protected readonly asFormGroup: typeof asFormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeMapRendererComponent, never>;
+    static ɵcmp: i0.ɵɵ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, switchChoiceCase };
+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.2.1",
+  "version": "0.3.0",
   "description": "Build fully-typed Angular Reactive Forms and Angular Material UI from a declarative, recursive form-description schema.",
   "keywords": [
     "angular",