@softheon/armature 21.2.0 → 21.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softheon/armature",
-  "version": "21.2.0",
+  "version": "21.2.2",
   "dependencies": {
     "tslib": "^2.8.1"
   },
@@ -24,7 +24,8 @@
     "angular-oauth2-oidc-jwks": "~20.0.0",
     "ngx-cookie-service": "^21.1.0",
     "rxjs": "~7.8.0",
-    "moment": "^2.29.4"
+    "moment": "^2.29.4",
+    "@types/json-schema": "^7.0.15"
   },
   "peerDependenciesMeta": {
     "ag-grid-community": {
@@ -32,6 +33,9 @@
     },
     "ag-grid-angular": {
       "optional": true
+    },
+    "@types/json-schema": {
+      "optional": true
     }
   },
   "module": "fesm2022/softheon-armature.mjs",
@@ -47,6 +51,10 @@
     "./ag-grid-components": {
       "types": "./types/softheon-armature-ag-grid-components.d.ts",
       "default": "./fesm2022/softheon-armature-ag-grid-components.mjs"
+    },
+    "./b2b": {
+      "types": "./types/softheon-armature-b2b.d.ts",
+      "default": "./fesm2022/softheon-armature-b2b.mjs"
     }
   },
   "sideEffects": false

package/types/softheon-armature-b2b.d.ts

@@ -0,0 +1,584 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { JSONSchema7 } from 'json-schema';
+export { JSONSchema7 as JsonSchema } from 'json-schema';
+
+/**
+ * @fileoverview Models for the SofB2BJsonEditorComponent.
+ *
+ * Public API types: JsonValue, JsonObject, FieldConfig.
+ * Internal types: JsonEntry, JsonNode, JsonNamespace.
+ *
+ * Consumers interact with the editor via JsonObject input/output and
+ * FieldConfig schema only. JsonEntry is internal to the editor's
+ * flatten/unflatten pipeline.
+ *
+ * File is intentionally free of Angular dependencies so it can be
+ * imported by both Angular components and plain TypeScript utilities
+ * (e.g. unit tests, data-manager helpers).
+ */
+/**
+ * Recursive type representing any valid JSON value.
+ * Replaces `any` in the public API for type safety while still
+ * supporting the full range of JSON structures.
+ *
+ * Usage:
+ *   JsonEntry.value, JsonNode.editableValue
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+/**
+ * A JSON object — a string-keyed dictionary of JsonValue.
+ * Extracted as a named interface to prevent TypeScript's
+ * "excessively deep type instantiation" error on recursive
+ * inline mapped types.
+ */
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+/**
+ * A single key/value entry in the flattened JSON representation.
+ * Used internally by the editor's flatten/unflatten pipeline.
+ * Consumers should not reference this type — pass JsonObject directly.
+ *
+ * Keys use path notation produced by flattenJson():
+ *   dot notation for objects:       "BillingInformation.APTCAmount"
+ *   bracket notation for arrays:    "Invoice.Payments[0].Amount"
+ *   quoted brackets for special keys: '["Discount Amount"]'
+ *                                     '["Corrected1095-B"]'
+ *
+ * @internal
+ */
+interface JsonEntry {
+    key: string;
+    value: JsonValue;
+}
+/**
+ * Supported input control types for scalar fields.
+ * The correct type is inferred from the value when not explicitly provided.
+ *
+ * Current rendering:
+ *   text     → <input type="text">
+ *   number   → <input type="number">
+ *   date     → <input type="date">
+ *   toggle   → <mat-slide-toggle>
+ *   select   → <mat-select>
+ *
+ * Extend this union as new input types are introduced.
+ * Adding a new type requires:
+ *   1. Adding it to this union
+ *   2. Adding a *ngSwitchCase in sof-b2b-json-node.component.html
+ *   3. Optionally updating inferInputType() in json-tree.utils.ts
+ */
+type FieldInputType = 'text' | 'number' | 'date' | 'toggle' | 'select';
+/**
+ * Configuration describing how a field should render and behave.
+ *
+ * Provided via companion schema: the [schema] input on SofB2BJsonEditorComponent,
+ * keyed by full path string (e.g. 'BillingInformation.APTCAmount').
+ *
+ * When no schema is provided, inputType is inferred from the value at
+ * build time via inferInputType() in json-tree.utils.ts.
+ */
+interface FieldConfig {
+    /**
+     * Which input control to render for this field.
+     * Inferred from the value if not explicitly provided.
+     */
+    inputType?: FieldInputType;
+    /**
+     * Override the display label shown above the input.
+     * Defaults to the key segment (e.g. "APTCAmount" from "BillingInformation.APTCAmount").
+     */
+    label?: string;
+    /**
+     * Prevents user edits when true.
+     * Read-only fields are visually distinct and skipped in tab order.
+     * Defaults to false.
+     */
+    readOnly?: boolean;
+    /** Placeholder text shown inside the input when the value is empty. */
+    placeholder?: string;
+    /**
+     * Option list for inputType 'select'.
+     * Required when inputType is 'select' — if omitted, falls back to 'text'.
+     */
+    options?: string[];
+}
+/**
+ * Discriminated union describing the structural type of a JSON value.
+ *
+ *   scalar — a primitive value (string, number, boolean, null)
+ *            renders as an editable input
+ *   array  — a JSON array
+ *            renders as a collapsible expansion panel with indexed children
+ *   object — a JSON object
+ *            renders as a collapsible expansion panel with named children
+ */
+type JsonNodeType = 'scalar' | 'array' | 'object';
+/**
+ * Internal representation of a single node in the JSON tree.
+ *
+ * Built once at data-load time by buildNode() in json-editor.utils.ts.
+ * Never mutated after construction except for editableValue (user edits)
+ * and key (prefix stripped by buildNamespaces()).
+ *
+ * Consumers should not reference this type — it is an implementation detail
+ * of the JsonEditor rendering layer.
+ */
+interface JsonNode {
+    /**
+     * Display key with dot-prefix stripped by buildNamespaces().
+     * e.g. "BillingInformation.APTCAmount" becomes "APTCAmount"
+     * after the "BillingInformation" namespace is extracted.
+     *
+     * Mutated by buildNamespaces() — use fullKey for any path operations.
+     */
+    key: string;
+    /**
+     * Original full path key as produced by flattenJson().
+     * e.g. "BillingInformation.APTCAmount" or "Invoice.Payments[0].Amount"
+     *
+     * Never mutated. Used by:
+     *   - flattenNamespaces() to reconstruct original keys on emit
+     *   - HTML [id] and [aria-label] bindings for accessibility
+     *   - Console warnings in guardrails
+     */
+    fullKey: string;
+    /** Structural type — drives which template branch renders this node. */
+    type: JsonNodeType;
+    /**
+     * Nesting depth starting from 0 at the top level.
+     * Used by the depth guardrail in buildNodesFromEntries() and json-node template.
+     */
+    depth: number;
+    /**
+     * Snapshot of the original value at tree-build time.
+     * Present only on scalar nodes. Never mutated after construction.
+     * Used by SofB2BJsonNodeComponent to compute dirty state
+     * (editableValue !== originalValue).
+     */
+    originalValue?: JsonValue;
+    /**
+     * The live editable value. Present only on scalar nodes.
+     * Bound directly to [(ngModel)] in sof-b2b-json-node.component.html.
+     * Initialised from the deep-cloned original value at build time —
+     * changes here never affect the consumer's source data.
+     */
+    editableValue?: JsonValue;
+    /**
+     * Child nodes. Present only on array and object nodes.
+     * Empty array means the container exists but has no items —
+     * rendered as an empty placeholder, not an expansion panel.
+     */
+    children?: JsonNode[];
+    /**
+     * Field rendering configuration. Always present — never undefined.
+     * Guarantees that sof-b2b-json-node.component.html can safely read
+     * node.config.inputType without null checks.
+     *
+     * Set at build time from (in priority order):
+     *   1. Companion schema lookup
+     *   2. inferInputType() result for scalars
+     *   3. Empty object {} for containers
+     */
+    config: FieldConfig;
+}
+/**
+ * A top-level grouping of JsonNodes sharing a dot-notation prefix.
+ *
+ * Built by buildNamespaces() in json-editor.utils.ts.
+ * Rendered as the outermost expansion panels in sof-b2b-json-editor.component.html.
+ *
+ * Examples from the billing JSON:
+ *   { prefix: 'BillingInformation', nodes: [...] }
+ *   { prefix: 'Invoice',            nodes: [...] }
+ *   { prefix: '—',                  nodes: [...] }  ← ungrouped top-level keys
+ *
+ * The "—" namespace is always sorted to the top by buildNamespaces().
+ */
+interface JsonNamespace {
+    /**
+     * The shared prefix extracted from node keys.
+     * e.g. "BillingInformation", "Invoice", "Adjustments"
+     * or "—" for keys without a dot-notation prefix
+     * (e.g. "COCOFileName", "ScanLine", "Discount Amount").
+     */
+    prefix: string;
+    /** All nodes belonging to this namespace, in original data order. */
+    nodes: JsonNode[];
+}
+
+/**
+ * @fileoverview Path parsing, flatten/unflatten, and normalization utilities.
+ *
+ * Converts between nested JSON objects and flat JsonEntry[] arrays using
+ * dot-notation and bracket-notation path strings.
+ *
+ * All functions are stateless and side-effect free.
+ * No Angular dependencies — fully unit-testable in isolation.
+ *
+ * Round-trip guarantee: unflattenJson(flattenJson(data)) deep-equals data
+ */
+
+/**
+ * Parses a path string into an array of typed segments.
+ *
+ * Handles:
+ *   "a.b.c"                    → ['a', 'b', 'c']
+ *   "a.b[0].c"                 → ['a', 'b', 0, 'c']
+ *   '["Discount Amount"]'      → ['Discount Amount']
+ *   'a["Corrected1095-B"].val' → ['a', 'Corrected1095-B', 'val']
+ *
+ * Three capture groups:
+ *   1 — plain key segment:   word chars only (no dots, brackets, quotes)
+ *   2 — numeric array index: [0], [1], [42]
+ *   3 — quoted bracket key:  ["any string here"]
+ */
+declare function parsePath(path: string): (string | number)[];
+/**
+ * Reconstructs a nested object from JsonEntry[].
+ * Parses both dot notation and bracket notation paths.
+ *
+ * Inverse of flattenJson — guarantees round-trip fidelity.
+ *
+ * @param entries Flat JsonEntry[] produced by flattenJson()
+ */
+declare function unflattenJson(entries: JsonEntry[]): JsonObject;
+/**
+ * Flattens a raw nested JSON object into JsonEntry[].
+ * Convenience wrapper around flattenJson() — used by SofB2BJsonEditorComponent
+ * to convert its JsonObject input into flat entries for tree building.
+ *
+ * @example
+ * normalizeToEntries({ BillingInformation: { APTCAmount: '0.00' } })
+ * // → [{ key: 'BillingInformation.APTCAmount', value: '0.00' }]
+ */
+declare function normalizeToEntries(input: JsonObject): JsonEntry[];
+
+/**
+ * @fileoverview Tree construction, value reconstruction, and namespace emission.
+ *
+ * Builds a JsonNode tree from flat JsonEntry[] for rendering, and reconstructs
+ * flat JsonEntry[] from the tree for emission back to the consumer.
+ *
+ * Also includes type inference, field config resolution, and validation.
+ *
+ * All functions are stateless and side-effect free (except console warnings).
+ * No Angular dependencies — fully unit-testable in isolation.
+ *
+ * Guardrails:
+ *   Max depth cap          — MAX_DEPTH constant in buildNodesFromEntries()
+ *   Duplicate key warning  — Set check in validateDuplicateKeys()
+ *   Undefined output guard — null coalesce in flattenNamespaces()
+ */
+
+/**
+ * MAX_DEPTH guardrail.
+ * Nodes beyond this depth are skipped rather than recursed into.
+ * Prevents call-stack overflow on pathologically deep structures.
+ */
+declare const MAX_DEPTH = 20;
+/**
+ * Duplicate key guardrail.
+ * Warns when two entries share the same key. The second occurrence
+ * silently overwrites the first, producing incorrect emitted data.
+ *
+ * @param entries The JsonEntry[] to check for duplicate keys
+ */
+declare function validateDuplicateKeys(entries: JsonEntry[]): void;
+/**
+ * Builds a JsonNode tree from flat JsonEntry[] by grouping path segments
+ * into their natural hierarchy.
+ *
+ * This is the core tree-building function. It takes fully-flattened entries
+ * (e.g. "AdjustmentReasons[0].Code") and reconstructs the nested structure
+ * that the template renders as collapsible expansion panels.
+ *
+ * Handles three value shapes:
+ *   1. Empty [] or {}      — object/array with zero length, render as empty container
+ *   2. Scalar / primitive  — null, string, number, boolean — render as input
+ *   3. Container           — multiple children or deeper path — recurse
+ *
+ * Depth guardrail — stops recursing beyond MAX_DEPTH.
+ *
+ * @param entries Flat JsonEntry[] with namespace prefix already stripped
+ * @param schema  Optional companion schema for field config
+ * @param depth   Current nesting depth (0 = top level within namespace)
+ */
+declare function buildNodesFromEntries(entries: JsonEntry[], schema?: Record<string, FieldConfig>, depth?: number): JsonNode[];
+/**
+ * Flattens JsonNamespace[] back into JsonEntry[] for emission.
+ *
+ * Undefined output guardrail — reconstructValue() returning undefined
+ * is coalesced to null rather than emitting undefined to the consumer.
+ *
+ * @param namespaces The current namespace tree to flatten
+ */
+declare function flattenNamespaces(namespaces: JsonNamespace[]): JsonEntry[];
+
+/**
+ * @fileoverview Search filtering and tree pruning utilities.
+ *
+ * Filters a JsonNamespace[] tree to only nodes matching a search term.
+ * Uses recursive tree pruning — non-matching branches are removed,
+ * matching ancestors are preserved.
+ *
+ * All functions are stateless and side-effect free.
+ * No Angular dependencies — fully unit-testable in isolation.
+ */
+
+/**
+ * Filters a JsonNamespace[] tree to only namespaces and nodes
+ * matching the search term. Uses tree pruning — non-matching branches
+ * are removed, matching ancestors are preserved.
+ *
+ * Returns the original array reference unchanged if term is below
+ * the minimum length — no filtering overhead on short terms.
+ *
+ * @param namespaces The full namespace tree to filter
+ * @param term       The search string (case-insensitive, min 2 chars)
+ */
+declare function filterNamespaces(namespaces: JsonNamespace[], term: string): JsonNamespace[];
+
+/**
+ * The Sof B2B JSON Editor Component
+   Root JsonEditor template.
+   Renders JsonNamespace[] as top-level expansion panels.
+   All child node rendering is delegated to sof-b2b-json-node.
+  */
+declare class SofB2BJsonEditorComponent implements OnInit {
+    /**
+     * Raw nested JSON object to edit.
+     * Internally flattened into JsonEntry[] for tree construction.
+     * ⚠️ Pass a new object reference to trigger re-computation.
+     */
+    readonly data: _angular_core.InputSignal<JsonObject>;
+    /**
+     * Optional JSON Schema (Draft 7+) describing the data shape.
+     * When provided, the editor parses it internally and uses it to configure
+     * field types, labels, and dropdown options at tree-build time.
+     * Fields not found in the schema fall back to inferInputType().
+     *
+     * @example
+     * const schema: JsonSchema = {
+     *   type: 'object',
+     *   properties: {
+     *     Theme: { type: 'string', enum: ['dark', 'light'] },
+     *     MaxRetries: { type: 'integer', title: 'Max Retries' },
+     *   },
+     * };
+     */
+    readonly schema: _angular_core.InputSignal<JSONSchema7>;
+    /** Debounce delay in ms before dataChanged emits. Default: 1500. */
+    readonly debounceMs: _angular_core.InputSignal<number>;
+    /** Message shown when data is empty. */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /** Message shown when search returns no matches. */
+    readonly noResultsMessage: _angular_core.InputSignal<string>;
+    /**
+     * Search term for filtering the tree.
+     * Minimum 2 characters to trigger filtering — shorter terms
+     * match too broadly and run the full recursive walk unnecessarily.
+     */
+    readonly searchTerm: _angular_core.InputSignal<string>;
+    /** Whether or not to render the json editor in read-only mode.
+     *  When true, all scalar fields display as plaintext, toggles are disabled,
+     *  and the change$/debounce subscription is never created. Default: false. */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Emits the full reconstructed nested JSON object after debounce period.
+     * Pass directly to any consumer expecting a JsonObject.
+     * 🛡️ Suppressed when readOnly is true.
+     */
+    readonly dataChanged: _angular_core.OutputEmitterRef<JsonObject>;
+    /**
+     * Emits an error message string when a parsing or validation error occurs.
+     * Consumers can subscribe to display errors in their own UI (snackbar, toast, etc.).
+     */
+    readonly parseError: _angular_core.OutputEmitterRef<string>;
+    /** Top-level namespace panels only — not nested array/object panels. */
+    readonly namespacePanels: _angular_core.Signal<readonly MatExpansionPanel[]>;
+    /**
+     * Parsed JSON Schema → flat Record<string, FieldConfig>.
+     * Recomputes when the schema input changes. Used internally by
+     * buildTree() for field config resolution. Consumers never see this.
+     */
+    private readonly parsedSchema;
+    /**
+     * Internal flat entries derived from the data input.
+     * Recomputes automatically when data() changes.
+     * Protected so the template can check entries().length for empty state.
+     */
+    protected readonly entries: _angular_core.Signal<JsonEntry[]>;
+    /**
+     * Full namespace tree built from internal entries.
+     * Recomputes automatically when data() or schema() changes.
+     * 🔑 Duplicate key validation runs on every recomputation.
+     */
+    protected readonly namespaces: _angular_core.Signal<JsonNamespace[]>;
+    /**
+     * Filtered namespace tree derived from namespaces + searchTerm.
+     * Recomputes automatically when either signal changes.
+     * No manual sync needed — computed() handles both inputs.
+     *
+     * This replaces the manual sync bug where filteredNamespaces
+     * started as [] and wasn't populated until a search fired.
+     */
+    protected readonly filteredNamespaces: _angular_core.Signal<JsonNamespace[]>;
+    /** The Internal state changes */
+    private readonly change$;
+    /**
+     * 💾 DestroyRef — takeUntilDestroyed() auto-completes the debounce
+     * subscription on component destroy, preventing memory leaks and
+     * emissions to destroyed parent components.
+     */
+    private readonly destroyRef;
+    ngOnInit(): void;
+    /** Programmatically opens all top-level namespace panels. */
+    openAll(): void;
+    /** Programmatically closes all top-level namespace panels. */
+    closeAll(): void;
+    /** Handles value changes from any child SofB2BJsonNodeComponent. Pushes into the debounce stream. */
+    protected onValueChanged(): void;
+    /**
+     * Groups flat JsonEntry[] into a namespace tree for rendering.
+     *
+     * Each entry's first path segment becomes the namespace prefix.
+     * Entries whose keys start with `[` (bracket notation) are grouped
+     * under a fallback "—" namespace and sorted to the top.
+     *
+     * Regex metacharacters in the prefix are escaped before stripping
+     * it from child keys (e.g. `$Settings.Foo` won't break the RegExp).
+     */
+    private buildTree;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SofB2BJsonEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SofB2BJsonEditorComponent, "sof-b2b-json-editor", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "schema": { "alias": "schema"; "required": false; "isSignal": true; }; "debounceMs": { "alias": "debounceMs"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "searchTerm"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "dataChanged": "dataChanged"; "parseError": "parseError"; }, never, never, true, never>;
+}
+
+/** The Sof B2B JSON Editor Node Component */
+declare class SofB2BJsonNodeComponent {
+    /**
+     * ChangeDetectorRef is ONLY needed for addItem() and removeItem().
+     * Those methods mutate node().children in place — the node signal reference
+     * doesn't change, so OnPush won't re-evaluate the @for loop without an
+     * explicit markForCheck(). All other reactivity in this component uses signals.
+     */
+    private readonly cdr;
+    /** The JsonNode to render. Required input. */
+    readonly node: _angular_core.InputSignal<JsonNode>;
+    /** When true, all fields render as non-editable plaintext. Passed from SofB2BJsonEditorComponent. */
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    /** Bubbles up from any depth to the root SofB2BJsonEditorComponent. */
+    readonly valueChanged: _angular_core.OutputEmitterRef<void>;
+    /** Exposed to template for the 📏 depth guardrail check. */
+    protected readonly maxDepth = 20;
+    /** Whether this node is an empty container (array/object with no children). */
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    /**
+     * Whether the scalar field has been edited (current value differs from original).
+     * Always false for non-scalar nodes. Updated imperatively on each ngModelChange
+     * because the `node` signal reference doesn't change when `editableValue` is
+     * mutated in place by ngModel — a computed() based on node() alone would never
+     * re-evaluate.
+     *
+     * Also recalculated when the `node` input changes (via effect) so that the
+     * initial render already reflects dirty state (e.g. when a parent rebuilds the
+     * tree after external data changes).
+     */
+    protected isDirty: boolean;
+    /**
+     * Whether this array node supports add/remove operations.
+     * True when: array type, has at least 1 child (provides template for cloning),
+     * and not in readOnly mode. Empty arrays show "(no schema)" instead.
+     */
+    protected readonly canModifyArray: _angular_core.Signal<boolean>;
+    /**
+     * Label for the "Add" button, e.g. "Add Member" for an array named "Members".
+     * Uses naive singularization (strip trailing "s") for a natural UX label.
+     */
+    protected readonly addButtonLabel: _angular_core.Signal<string>;
+    constructor();
+    /** Label describing the child count, e.g. "3 items" or "2 fields". */
+    protected readonly childLabel: _angular_core.Signal<string>;
+    /**
+     * Sanitized id safe for use in HTML id attributes and CSS selectors.
+     * node.fullKey may contain brackets and quotes (e.g. ["Discount Amount"])
+     * which are invalid in CSS selectors and break browser extension queries.
+     */
+    protected readonly safeId: _angular_core.Signal<string>;
+    /** Relays child node value changes upward to the parent. Enables event bubbling through the recursive tree. */
+    protected onChildChanged(): void;
+    /**
+     * Called from the template on every `(ngModelChange)` for scalar inputs.
+     * Updates the dirty flag by comparing the current editableValue against the
+     * original snapshot, then bubbles the change event upward.
+     */
+    protected onValueChanged(): void;
+    /**
+     * Adds a new item to this array node by cloning the first child as a template.
+     * The cloned item's scalar descendants have originalValue = editableValue,
+     * so they do not appear dirty. Replaces the children array reference and
+     * marks the view for check since the node signal itself doesn't change.
+     */
+    protected addItem(): void;
+    /**
+     * Removes an item from this array node at the given index.
+     * Minimum items = 1 — cannot delete the last remaining item.
+     * After removal, reindexes remaining children to keep display keys sequential.
+     */
+    protected removeItem(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SofB2BJsonNodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SofB2BJsonNodeComponent, "sof-b2b-json-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class SofB2BModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SofB2BModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SofB2BModule, never, [typeof SofB2BJsonEditorComponent, typeof SofB2BJsonNodeComponent], [typeof SofB2BJsonEditorComponent, typeof SofB2BJsonNodeComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SofB2BModule>;
+}
+
+/**
+ * @fileoverview JSON Schema → FieldConfig parser.
+ *
+ * Converts a standard JSON Schema (Draft 7+) into a flat
+ * Record<string, FieldConfig> keyed by dot-notation paths.
+ * The output plugs directly into SofB2BJsonEditorComponent's [schema] input
+ * and is consumed by buildFieldConfig() at tree-build time.
+ *
+ * Supported JSON Schema keywords:
+ *   type        → maps to FieldInputType ('text', 'number', 'toggle', 'select')
+ *   enum        → options[] + inputType 'select'
+ *   $id / title → label override
+ *   properties  → recursed into, building dot-notation paths
+ *   items       → recursed into for array element schemas
+ *
+ * Intentionally ignored (Tier 1 — basic support):
+ *   pattern, format, minLength, maxLength, minimum, maximum,
+ *   additionalProperties, required, allOf, anyOf, oneOf, $ref
+ *
+ * All functions are stateless and side-effect free.
+ * No Angular dependencies — fully unit-testable in isolation.
+ */
+
+/**
+ * Parses a JSON Schema document into a flat Record<string, FieldConfig>
+ * suitable for passing to SofB2BJsonEditorComponent's [schema] input.
+ *
+ * @param schema  A JSON Schema object (Draft 7+ compatible).
+ *                Pass null/undefined for a no-op that returns {}.
+ * @returns       A flat map of dot-notation paths → FieldConfig.
+ *
+ * @example
+ * const schema = await fetch('/api/schema').then(r => r.json());
+ * const fieldConfigs = parseJsonSchema(schema);
+ * // fieldConfigs = {
+ * //   'Settings.Theme': { inputType: 'select', options: ['dark', 'light'] },
+ * //   'Settings.MaxRetries': { inputType: 'number' },
+ * //   'Settings.Enabled': { inputType: 'toggle' },
+ * // }
+ */
+declare function parseJsonSchema(schema: JSONSchema7 | null | undefined): Record<string, FieldConfig>;
+
+export { MAX_DEPTH, SofB2BJsonEditorComponent, SofB2BJsonNodeComponent, SofB2BModule, buildNodesFromEntries, filterNamespaces, flattenNamespaces, normalizeToEntries, parseJsonSchema, parsePath, unflattenJson, validateDuplicateKeys };
+export type { FieldConfig, JsonEntry, JsonNamespace, JsonNode, JsonObject, JsonValue };

package/types/softheon-armature.d.ts

@@ -2072,7 +2072,7 @@ declare class ValidationKeys {
  * @description
  * - This component can be used as a single select or multi-select.
  * - Can be used with a reactive formControlName.
- * - Can be used with [(ngModal)] binding.
+ * - Can be used with [(ngModel)] binding.
  * - Can be used without a form using the (selectionChange) output event.
  */
 declare class SofSelectComponent implements ControlValueAccessor, Validator, OnInit, AfterViewInit, OnDestroy {
@@ -6785,6 +6785,12 @@ declare class SofSnackbarComponent {
     private _snackbarService;
     /** Snackbars array signal */
     snackbars: Signal<Array<_SnackbarInternal>>;
+    /** Position from top for the snackbar container */
+    positionTop: string | undefined;
+    /** Position from right for the snackbar container (default: 24px) */
+    positionRight: string;
+    /** Position from bottom for the snackbar container (default: 24px) */
+    positionBottom: string;
     /** Live announcer for screen reader wcag */
     private _liveAnnouncerService;
     /** Translation service */
@@ -6813,7 +6819,7 @@ declare class SofSnackbarComponent {
     */
     handleAction(snackbar: _SnackbarInternal): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SofSnackbarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SofSnackbarComponent, "sof-snackbar", never, {}, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SofSnackbarComponent, "sof-snackbar", never, { "positionTop": { "alias": "positionTop"; "required": false; }; "positionRight": { "alias": "positionRight"; "required": false; }; "positionBottom": { "alias": "positionBottom"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /** Toast Model */
@@ -6879,6 +6885,10 @@ declare class TextOverflowEllipsisTooltipDirective implements AfterViewInit, OnD
      * @note If no tooltip text provided, will use the elements 'textContent'
     */
     tooltipText: string;
+    /** Custom classes for the tooltip */
+    tooltipClass: string | Array<string>;
+    /** Possible positions for a tooltip : "left" | "right" | "above" | "below" | "before" | "after" */
+    tooltipPosition: TooltipPosition;
     /** Is the element overflowing */
     private isOverflowing;
     /** The resize observer */
@@ -6905,7 +6915,7 @@ declare class TextOverflowEllipsisTooltipDirective implements AfterViewInit, OnD
     /** Hide the tooltip on mouseleave */
     onMouseLeave(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TextOverflowEllipsisTooltipDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TextOverflowEllipsisTooltipDirective, "[textOverflowEllipsisTooltip]", never, { "tooltipText": { "alias": "textOverflowEllipsisTooltip"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextOverflowEllipsisTooltipDirective, "[textOverflowEllipsisTooltip]", never, { "tooltipText": { "alias": "textOverflowEllipsisTooltip"; "required": false; }; "tooltipClass": { "alias": "ellipsisTooltipClass"; "required": false; }; "tooltipPosition": { "alias": "ellipsisTooltipPosition"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class MfeModule {