@seniorsistemas/data-seniorx-core 3.0.0 → 3.1.0

package/esm2022/features/dynamic-form/dynamic-form-field.directive.mjs

@@ -0,0 +1,178 @@
+import { Directive, inject, Input, ViewContainerRef } from '@angular/core';
+import { DynamicFormRegistry } from './dynamic-form.registry';
+import * as i0 from "@angular/core";
+export class DynamicFormFieldDirective {
+    viewContainer = inject(ViewContainerRef);
+    componentRef = null;
+    field;
+    formGroup;
+    ngOnChanges(changes) {
+        if (changes['field'] && this.field) {
+            this.renderField();
+        }
+        if (changes['formGroup'] && this.componentRef) {
+            this.updateFormControl();
+        }
+    }
+    ngOnDestroy() {
+        this.componentRef?.destroy();
+    }
+    renderField() {
+        this.componentRef?.destroy();
+        this.viewContainer.clear();
+        const component = DynamicFormRegistry.resolveField(this.field.type);
+        if (!component) {
+            return;
+        }
+        this.componentRef = this.viewContainer.createComponent(component);
+        this.applyFieldConfig();
+        this.updateFormControl();
+    }
+    applyFieldConfig() {
+        if (!this.componentRef) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        this.mapCommonInputs(instance);
+        this.mapRequiredAndDisabled(instance);
+        this.mapOptionsAndRange(instance);
+        this.mapExtraInputs(instance);
+    }
+    // Map common field config properties to component inputs. Not every registered component
+    // declares all of these (e.g. sdc-button has no `placeholder`/`required`, sdc-autocomplete has
+    // no `label`) — `ComponentRef.setInput()` throws NG0303 for an input the component doesn't
+    // declare, so each one is gated on the instance actually having that property. The `'x' in
+    // instance` check alone isn't perfectly reliable (a component can have a plain, non-`@Input()`
+    // class property of the same name), so `trySetInput` also swallows the NG0303 as a last resort.
+    mapCommonInputs(instance) {
+        if (this.field.label !== undefined && 'label' in instance) {
+            this.trySetInput('label', this.field.label);
+        }
+        if (this.field.placeholder !== undefined && 'placeholder' in instance) {
+            this.trySetInput('placeholder', this.field.placeholder);
+        }
+        if (this.field.width !== undefined && 'width' in instance) {
+            this.trySetInput('width', this.field.width);
+        }
+        if (this.field.maxlength !== undefined && 'maxlength' in instance) {
+            this.trySetInput('maxlength', this.field.maxlength);
+        }
+    }
+    mapRequiredAndDisabled(instance) {
+        const required = typeof this.field.required === 'function' ? this.field.required() : (this.field.required ?? false);
+        const disabled = typeof this.field.disabled === 'function' ? this.field.disabled() : (this.field.disabled ?? false);
+        if ('required' in instance) {
+            this.trySetInput('required', required);
+        }
+        if ('disabled' in instance) {
+            this.trySetInput('disabled', disabled);
+        }
+    }
+    // Pass options for select-like fields and min/max for number/date fields
+    mapOptionsAndRange(instance) {
+        this.mapOptions(instance);
+        this.mapRange(instance);
+    }
+    // Pass options for select-like fields
+    mapOptions(instance) {
+        if (!this.field.options) {
+            return;
+        }
+        if ('options' in instance) {
+            this.trySetInput('options', this.field.options);
+        }
+        else if ('suggestions' in instance) {
+            // List-driven fields that don't use the generic `options` contract (e.g.
+            // sdc-autocomplete's `suggestions`/`suggestionLabel`/`suggestionValue`) still accept
+            // the standard `{ text, value }[]` shape authored on `DynamicFieldConfig.options` —
+            // without this, every consumer had to duplicate its option list via a component-specific
+            // extra input just to populate the field.
+            this.trySetInput('suggestions', this.field.options);
+            if ('suggestionLabel' in instance) {
+                this.trySetInput('suggestionLabel', 'text');
+            }
+            if ('suggestionValue' in instance) {
+                this.trySetInput('suggestionValue', 'value');
+            }
+        }
+        else {
+            // Component has no `options`/`suggestions`-like input declared — nothing to map.
+        }
+    }
+    // Pass min/max for number/date fields
+    mapRange(instance) {
+        if (this.field.min !== undefined && 'min' in instance) {
+            this.trySetInput('min', this.field.min);
+        }
+        if (this.field.max !== undefined && 'max' in instance) {
+            this.trySetInput('max', this.field.max);
+        }
+    }
+    // Pass any extra config properties that match component inputs
+    mapExtraInputs(instance) {
+        const reservedKeys = new Set(['type', 'name', 'label', 'placeholder', 'required', 'disabled', 'hidden', 'width', 'gridColumn', 'options', 'min', 'max', 'maxlength']);
+        for (const [key, val] of Object.entries(this.field)) {
+            if (!reservedKeys.has(key) && key in instance) {
+                this.trySetInput(key, val);
+            }
+        }
+    }
+    trySetInput(key, value) {
+        try {
+            this.componentRef?.setInput(key, value);
+        }
+        catch {
+            // Property exists on the instance but isn't a declared @Input() — skip it.
+        }
+    }
+    updateFormControl() {
+        if (!this.componentRef || !this.formGroup || !this.field?.name) {
+            return;
+        }
+        const control = this.formGroup.get(this.field.name);
+        if (!control) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        this.writeValueToInstance(instance, control.value);
+        this.bindInstanceCallbacksToControl(instance, control);
+        // Subscribe to form control value changes to push back to CVA
+        control.valueChanges.subscribe((value) => {
+            this.writeValueToInstance(instance, value);
+        });
+    }
+    // If the component has writeValue (CVA), push the value into it
+    writeValueToInstance(instance, value) {
+        if ('writeValue' in instance && typeof instance['writeValue'] === 'function') {
+            instance['writeValue'](value);
+        }
+    }
+    bindInstanceCallbacksToControl(instance, control) {
+        if ('registerOnChange' in instance && typeof instance['registerOnChange'] === 'function') {
+            instance['registerOnChange']((value) => {
+                control.setValue(value, { emitEvent: true });
+                control.markAsDirty();
+            });
+        }
+        if ('registerOnTouched' in instance && typeof instance['registerOnTouched'] === 'function') {
+            instance['registerOnTouched'](() => {
+                control.markAsTouched();
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormFieldDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFormFieldDirective, isStandalone: true, selector: "[sdcDynamicFormField]", inputs: { field: ["sdcDynamicFormField", "field"], formGroup: "formGroup" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sdcDynamicFormField]',
+                    standalone: true
+                }]
+        }], propDecorators: { field: [{
+                type: Input,
+                args: ['sdcDynamicFormField']
+            }], formGroup: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-field.directive.js","sourceRoot":"","sources":["../../../../../lib/src/features/dynamic-form/dynamic-form-field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, Directive, inject, Input, OnChanges, OnDestroy, SimpleChanges, ViewContainerRef } from '@angular/core';\nimport { AbstractControl, FormGroup } from '@angular/forms';\nimport { DynamicFormRegistry } from './dynamic-form.registry';\nimport type { DynamicFieldConfig } from '../../core/types/dynamic-form.type';\n\n@Directive({\n    selector: '[sdcDynamicFormField]',\n    standalone: true\n})\nexport class DynamicFormFieldDirective implements OnChanges, OnDestroy {\n    private readonly viewContainer = inject(ViewContainerRef);\n    private componentRef: ComponentRef<unknown> | null = null;\n\n    @Input('sdcDynamicFormField') field!: DynamicFieldConfig;\n    @Input() formGroup!: FormGroup;\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (changes['field'] && this.field) {\n            this.renderField();\n        }\n        if (changes['formGroup'] && this.componentRef) {\n            this.updateFormControl();\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.componentRef?.destroy();\n    }\n\n    private renderField(): void {\n        this.componentRef?.destroy();\n        this.viewContainer.clear();\n\n        const component = DynamicFormRegistry.resolveField(this.field.type);\n        if (!component) {\n            return;\n        }\n\n        this.componentRef = this.viewContainer.createComponent(component);\n        this.applyFieldConfig();\n        this.updateFormControl();\n    }\n\n    private applyFieldConfig(): void {\n        if (!this.componentRef) {\n            return;\n        }\n\n        const instance = this.componentRef.instance as Record<string, unknown>;\n\n        this.mapCommonInputs(instance);\n        this.mapRequiredAndDisabled(instance);\n        this.mapOptionsAndRange(instance);\n        this.mapExtraInputs(instance);\n    }\n\n    // Map common field config properties to component inputs. Not every registered component\n    // declares all of these (e.g. sdc-button has no `placeholder`/`required`, sdc-autocomplete has\n    // no `label`) — `ComponentRef.setInput()` throws NG0303 for an input the component doesn't\n    // declare, so each one is gated on the instance actually having that property. The `'x' in\n    // instance` check alone isn't perfectly reliable (a component can have a plain, non-`@Input()`\n    // class property of the same name), so `trySetInput` also swallows the NG0303 as a last resort.\n    private mapCommonInputs(instance: Record<string, unknown>): void {\n        if (this.field.label !== undefined && 'label' in instance) {\n            this.trySetInput('label', this.field.label);\n        }\n        if (this.field.placeholder !== undefined && 'placeholder' in instance) {\n            this.trySetInput('placeholder', this.field.placeholder);\n        }\n        if (this.field.width !== undefined && 'width' in instance) {\n            this.trySetInput('width', this.field.width);\n        }\n        if (this.field.maxlength !== undefined && 'maxlength' in instance) {\n            this.trySetInput('maxlength', this.field.maxlength);\n        }\n    }\n\n    private mapRequiredAndDisabled(instance: Record<string, unknown>): void {\n        const required = typeof this.field.required === 'function' ? this.field.required() : (this.field.required ?? false);\n        const disabled = typeof this.field.disabled === 'function' ? this.field.disabled() : (this.field.disabled ?? false);\n        if ('required' in instance) {\n            this.trySetInput('required', required);\n        }\n        if ('disabled' in instance) {\n            this.trySetInput('disabled', disabled);\n        }\n    }\n\n    // Pass options for select-like fields and min/max for number/date fields\n    private mapOptionsAndRange(instance: Record<string, unknown>): void {\n        this.mapOptions(instance);\n        this.mapRange(instance);\n    }\n\n    // Pass options for select-like fields\n    private mapOptions(instance: Record<string, unknown>): void {\n        if (!this.field.options) {\n            return;\n        }\n\n        if ('options' in instance) {\n            this.trySetInput('options', this.field.options);\n        } else if ('suggestions' in instance) {\n            // List-driven fields that don't use the generic `options` contract (e.g.\n            // sdc-autocomplete's `suggestions`/`suggestionLabel`/`suggestionValue`) still accept\n            // the standard `{ text, value }[]` shape authored on `DynamicFieldConfig.options` —\n            // without this, every consumer had to duplicate its option list via a component-specific\n            // extra input just to populate the field.\n            this.trySetInput('suggestions', this.field.options);\n            if ('suggestionLabel' in instance) {\n                this.trySetInput('suggestionLabel', 'text');\n            }\n            if ('suggestionValue' in instance) {\n                this.trySetInput('suggestionValue', 'value');\n            }\n        } else {\n            // Component has no `options`/`suggestions`-like input declared — nothing to map.\n        }\n    }\n\n    // Pass min/max for number/date fields\n    private mapRange(instance: Record<string, unknown>): void {\n        if (this.field.min !== undefined && 'min' in instance) {\n            this.trySetInput('min', this.field.min);\n        }\n        if (this.field.max !== undefined && 'max' in instance) {\n            this.trySetInput('max', this.field.max);\n        }\n    }\n\n    // Pass any extra config properties that match component inputs\n    private mapExtraInputs(instance: Record<string, unknown>): void {\n        const reservedKeys = new Set(['type', 'name', 'label', 'placeholder', 'required', 'disabled', 'hidden', 'width', 'gridColumn', 'options', 'min', 'max', 'maxlength']);\n        for (const [key, val] of Object.entries(this.field)) {\n            if (!reservedKeys.has(key) && key in instance) {\n                this.trySetInput(key, val);\n            }\n        }\n    }\n\n    private trySetInput(key: string, value: unknown): void {\n        try {\n            this.componentRef?.setInput(key, value);\n        } catch {\n            // Property exists on the instance but isn't a declared @Input() — skip it.\n        }\n    }\n\n    private updateFormControl(): void {\n        if (!this.componentRef || !this.formGroup || !this.field?.name) {\n            return;\n        }\n\n        const control = this.formGroup.get(this.field.name);\n        if (!control) {\n            return;\n        }\n\n        const instance = this.componentRef.instance as Record<string, unknown>;\n\n        this.writeValueToInstance(instance, control.value);\n        this.bindInstanceCallbacksToControl(instance, control);\n\n        // Subscribe to form control value changes to push back to CVA\n        control.valueChanges.subscribe((value: unknown) => {\n            this.writeValueToInstance(instance, value);\n        });\n    }\n\n    // If the component has writeValue (CVA), push the value into it\n    private writeValueToInstance(instance: Record<string, unknown>, value: unknown): void {\n        if ('writeValue' in instance && typeof instance['writeValue'] === 'function') {\n            (instance['writeValue'] as (v: unknown) => void)(value);\n        }\n    }\n\n    private bindInstanceCallbacksToControl(instance: Record<string, unknown>, control: AbstractControl): void {\n        if ('registerOnChange' in instance && typeof instance['registerOnChange'] === 'function') {\n            (instance['registerOnChange'] as (fn: (v: unknown) => void) => void)((value: unknown) => {\n                control.setValue(value, { emitEvent: true });\n                control.markAsDirty();\n            });\n        }\n        if ('registerOnTouched' in instance && typeof instance['registerOnTouched'] === 'function') {\n            (instance['registerOnTouched'] as (fn: () => void) => void)(() => {\n                control.markAsTouched();\n            });\n        }\n    }\n}\n"]}

package/esm2022/features/dynamic-form/dynamic-form.component.mjs

@@ -0,0 +1,60 @@
+import { CommonModule } from '@angular/common';
+import { Component, ChangeDetectionStrategy, Input, ViewEncapsulation } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { DynamicFormFieldDirective } from './dynamic-form-field.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class DynamicFormComponent {
+    form;
+    fields = [];
+    isStructure(item) {
+        return item.type === 'row' || item.type === 'grid';
+    }
+    isField(item) {
+        return !this.isStructure(item);
+    }
+    isFieldVisible(field) {
+        if (field.hidden === undefined) {
+            return true;
+        }
+        return typeof field.hidden === 'function' ? !field.hidden() : !field.hidden;
+    }
+    getGridStyle(structure) {
+        if (structure.type === 'grid') {
+            return {
+                display: 'grid',
+                'grid-template-columns': `repeat(${structure.columns ?? 2}, 1fr)`,
+                gap: structure.gap ?? '1rem'
+            };
+        }
+        return {};
+    }
+    getFieldStyle(field) {
+        const style = {};
+        if (field.gridColumn) {
+            style['grid-column'] = field.gridColumn;
+        }
+        return style;
+    }
+    // Tracks by the field's own `name` (a `DynamicStructureConfig` has no `name`, so it falls
+    // back to its position). Consumers commonly rebuild `fields` with `.map(f => ({ ...f, ... }))`
+    // to toggle a shared property (disabled/required/etc.) across every field — tracking by
+    // object identity (`track item`) would treat every one of those as a brand new item and
+    // destroy + recreate the whole rendered field list on every such update.
+    trackItem(index, item) {
+        return this.isField(item) ? item.name : `structure-${index}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: DynamicFormComponent, isStandalone: true, selector: "sdc-dynamic-form", inputs: { form: "form", fields: "fields" }, ngImport: i0, template: "<div class=\"sdc-dynamic-form\">\n  @for (item of fields; track trackItem($index, item)) {\n    @if (isStructure(item)) {\n      <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(item)\">\n        @for (child of item.fields; track trackItem($index, child)) {\n          @if (isField(child) && isFieldVisible(child)) {\n            <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(child)\">\n              <ng-container [sdcDynamicFormField]=\"child\" [formGroup]=\"form\"></ng-container>\n            </div>\n          } @else if (isStructure(child)) {\n            <!-- Nested structure -->\n            <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(child)\">\n              @for (nested of child.fields; track trackItem($index, nested)) {\n                @if (isField(nested) && isFieldVisible(nested)) {\n                  <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(nested)\">\n                    <ng-container [sdcDynamicFormField]=\"nested\" [formGroup]=\"form\"></ng-container>\n                  </div>\n                }\n              }\n            </div>\n          }\n        }\n      </div>\n    } @else if (isFieldVisible(item)) {\n      <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(item)\">\n        <ng-container [sdcDynamicFormField]=\"item\" [formGroup]=\"form\"></ng-container>\n      </div>\n    }\n  }\n</div>\n", styles: [":host{display:block}.sdc-dynamic-form{display:flex;flex-direction:column;gap:var(--sdc-dynamic-form-gap, 1rem)}.sdc-dynamic-form__structure{display:flex;flex-wrap:wrap;gap:var(--sdc-dynamic-form-structure-gap, 1rem)}.sdc-dynamic-form__field{min-width:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: DynamicFormFieldDirective, selector: "[sdcDynamicFormField]", inputs: ["sdcDynamicFormField", "formGroup"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sdc-dynamic-form', standalone: true, imports: [CommonModule, ReactiveFormsModule, DynamicFormFieldDirective], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.Emulated, template: "<div class=\"sdc-dynamic-form\">\n  @for (item of fields; track trackItem($index, item)) {\n    @if (isStructure(item)) {\n      <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(item)\">\n        @for (child of item.fields; track trackItem($index, child)) {\n          @if (isField(child) && isFieldVisible(child)) {\n            <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(child)\">\n              <ng-container [sdcDynamicFormField]=\"child\" [formGroup]=\"form\"></ng-container>\n            </div>\n          } @else if (isStructure(child)) {\n            <!-- Nested structure -->\n            <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(child)\">\n              @for (nested of child.fields; track trackItem($index, nested)) {\n                @if (isField(nested) && isFieldVisible(nested)) {\n                  <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(nested)\">\n                    <ng-container [sdcDynamicFormField]=\"nested\" [formGroup]=\"form\"></ng-container>\n                  </div>\n                }\n              }\n            </div>\n          }\n        }\n      </div>\n    } @else if (isFieldVisible(item)) {\n      <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(item)\">\n        <ng-container [sdcDynamicFormField]=\"item\" [formGroup]=\"form\"></ng-container>\n      </div>\n    }\n  }\n</div>\n", styles: [":host{display:block}.sdc-dynamic-form{display:flex;flex-direction:column;gap:var(--sdc-dynamic-form-gap, 1rem)}.sdc-dynamic-form__structure{display:flex;flex-wrap:wrap;gap:var(--sdc-dynamic-form-structure-gap, 1rem)}.sdc-dynamic-form__field{min-width:0}\n"] }]
+        }], propDecorators: { form: [{
+                type: Input,
+                args: [{ required: true }]
+            }], fields: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form.component.js","sourceRoot":"","sources":["../../../../../lib/src/features/dynamic-form/dynamic-form.component.ts","../../../../../lib/src/features/dynamic-form/dynamic-form.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC7F,OAAO,EAAa,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;;;;AAY3E,MAAM,OAAO,oBAAoB;IACF,IAAI,CAAa;IACnC,MAAM,GAAoD,EAAE,CAAC;IAEtE,WAAW,CAAC,IAAiD;QACzD,OAAO,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC;IACvD,CAAC;IAED,OAAO,CAAC,IAAiD;QACrD,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,cAAc,CAAC,KAAyB;QACpC,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,OAAO,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;IAChF,CAAC;IAED,YAAY,CAAC,SAAiC;QAC1C,IAAI,SAAS,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5B,OAAO;gBACH,OAAO,EAAE,MAAM;gBACf,uBAAuB,EAAE,UAAU,SAAS,CAAC,OAAO,IAAI,CAAC,QAAQ;gBACjE,GAAG,EAAE,SAAS,CAAC,GAAG,IAAI,MAAM;aAC/B,CAAC;QACN,CAAC;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAED,aAAa,CAAC,KAAyB;QACnC,MAAM,KAAK,GAA2B,EAAE,CAAC;QACzC,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACnB,KAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC;QAC5C,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,0FAA0F;IAC1F,+FAA+F;IAC/F,wFAAwF;IACxF,wFAAwF;IACxF,yEAAyE;IACzE,SAAS,CAAC,KAAa,EAAE,IAAiD;QACtE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,KAAK,EAAE,CAAC;IACjE,CAAC;wGA7CQ,oBAAoB;4FAApB,oBAAoB,wHChBjC,05CA8BA,wTDpBc,YAAY,mHAAE,mBAAmB,4UAAE,yBAAyB;;4FAM7D,oBAAoB;kBAThC,SAAS;+BACI,kBAAkB,cAChB,IAAI,WACP,CAAC,YAAY,EAAE,mBAAmB,EAAE,yBAAyB,CAAC,mBAGtD,uBAAuB,CAAC,MAAM,iBAChC,iBAAiB,CAAC,QAAQ;8BAGd,IAAI;sBAA9B,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAChB,MAAM;sBAAd,KAAK","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, ChangeDetectionStrategy, Input, ViewEncapsulation } from '@angular/core';\nimport { FormGroup, ReactiveFormsModule } from '@angular/forms';\n\nimport { DynamicFormFieldDirective } from './dynamic-form-field.directive';\nimport type { DynamicFieldConfig, DynamicStructureConfig } from '../../core/types/dynamic-form.type';\n\n@Component({\n    selector: 'sdc-dynamic-form',\n    standalone: true,\n    imports: [CommonModule, ReactiveFormsModule, DynamicFormFieldDirective],\n    templateUrl: './dynamic-form.component.html',\n    styleUrl: './dynamic-form.component.scss',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.Emulated\n})\nexport class DynamicFormComponent {\n    @Input({ required: true }) form!: FormGroup;\n    @Input() fields: (DynamicFieldConfig | DynamicStructureConfig)[] = [];\n\n    isStructure(item: DynamicFieldConfig | DynamicStructureConfig): item is DynamicStructureConfig {\n        return item.type === 'row' || item.type === 'grid';\n    }\n\n    isField(item: DynamicFieldConfig | DynamicStructureConfig): item is DynamicFieldConfig {\n        return !this.isStructure(item);\n    }\n\n    isFieldVisible(field: DynamicFieldConfig): boolean {\n        if (field.hidden === undefined) {\n            return true;\n        }\n        return typeof field.hidden === 'function' ? !field.hidden() : !field.hidden;\n    }\n\n    getGridStyle(structure: DynamicStructureConfig): Record<string, string> {\n        if (structure.type === 'grid') {\n            return {\n                display: 'grid',\n                'grid-template-columns': `repeat(${structure.columns ?? 2}, 1fr)`,\n                gap: structure.gap ?? '1rem'\n            };\n        }\n        return {};\n    }\n\n    getFieldStyle(field: DynamicFieldConfig): Record<string, string> {\n        const style: Record<string, string> = {};\n        if (field.gridColumn) {\n            style['grid-column'] = field.gridColumn;\n        }\n        return style;\n    }\n\n    // Tracks by the field's own `name` (a `DynamicStructureConfig` has no `name`, so it falls\n    // back to its position). Consumers commonly rebuild `fields` with `.map(f => ({ ...f, ... }))`\n    // to toggle a shared property (disabled/required/etc.) across every field — tracking by\n    // object identity (`track item`) would treat every one of those as a brand new item and\n    // destroy + recreate the whole rendered field list on every such update.\n    trackItem(index: number, item: DynamicFieldConfig | DynamicStructureConfig): string {\n        return this.isField(item) ? item.name : `structure-${index}`;\n    }\n}\n","<div class=\"sdc-dynamic-form\">\n  @for (item of fields; track trackItem($index, item)) {\n    @if (isStructure(item)) {\n      <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(item)\">\n        @for (child of item.fields; track trackItem($index, child)) {\n          @if (isField(child) && isFieldVisible(child)) {\n            <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(child)\">\n              <ng-container [sdcDynamicFormField]=\"child\" [formGroup]=\"form\"></ng-container>\n            </div>\n          } @else if (isStructure(child)) {\n            <!-- Nested structure -->\n            <div class=\"sdc-dynamic-form__structure\" [ngStyle]=\"getGridStyle(child)\">\n              @for (nested of child.fields; track trackItem($index, nested)) {\n                @if (isField(nested) && isFieldVisible(nested)) {\n                  <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(nested)\">\n                    <ng-container [sdcDynamicFormField]=\"nested\" [formGroup]=\"form\"></ng-container>\n                  </div>\n                }\n              }\n            </div>\n          }\n        }\n      </div>\n    } @else if (isFieldVisible(item)) {\n      <div class=\"sdc-dynamic-form__field\" [ngStyle]=\"getFieldStyle(item)\">\n        <ng-container [sdcDynamicFormField]=\"item\" [formGroup]=\"form\"></ng-container>\n      </div>\n    }\n  }\n</div>\n"]}

package/esm2022/features/dynamic-form/dynamic-form.registry.mjs

@@ -0,0 +1,13 @@
+export class DynamicFormRegistry {
+    static fields = new Map();
+    static registerField(type, component) {
+        this.fields.set(type, component);
+    }
+    static resolveField(type) {
+        return this.fields.get(type);
+    }
+    static registerMany(mappings) {
+        mappings.forEach(({ type, component }) => this.registerField(type, component));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1mb3JtLnJlZ2lzdHJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL3NyYy9mZWF0dXJlcy9keW5hbWljLWZvcm0vZHluYW1pYy1mb3JtLnJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxtQkFBbUI7SUFDcEIsTUFBTSxDQUFVLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBeUIsQ0FBQztJQUVsRSxNQUFNLENBQUMsYUFBYSxDQUFDLElBQXNCLEVBQUUsU0FBd0I7UUFDakUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxNQUFNLENBQUMsWUFBWSxDQUFDLElBQVk7UUFDNUIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQsTUFBTSxDQUFDLFlBQVksQ0FBQyxRQUFxRTtRQUNyRixRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDbkYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgRHluYW1pY0ZpZWxkVHlwZSB9IGZyb20gJy4uLy4uL2NvcmUvdHlwZXMvZHluYW1pYy1mb3JtLnR5cGUnO1xuXG5leHBvcnQgY2xhc3MgRHluYW1pY0Zvcm1SZWdpc3RyeSB7XG4gICAgcHJpdmF0ZSBzdGF0aWMgcmVhZG9ubHkgZmllbGRzID0gbmV3IE1hcDxzdHJpbmcsIFR5cGU8dW5rbm93bj4+KCk7XG5cbiAgICBzdGF0aWMgcmVnaXN0ZXJGaWVsZCh0eXBlOiBEeW5hbWljRmllbGRUeXBlLCBjb21wb25lbnQ6IFR5cGU8dW5rbm93bj4pOiB2b2lkIHtcbiAgICAgICAgdGhpcy5maWVsZHMuc2V0KHR5cGUsIGNvbXBvbmVudCk7XG4gICAgfVxuXG4gICAgc3RhdGljIHJlc29sdmVGaWVsZCh0eXBlOiBzdHJpbmcpOiBUeXBlPHVua25vd24+IHwgdW5kZWZpbmVkIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuZmllbGRzLmdldCh0eXBlKTtcbiAgICB9XG5cbiAgICBzdGF0aWMgcmVnaXN0ZXJNYW55KG1hcHBpbmdzOiBBcnJheTx7IHR5cGU6IER5bmFtaWNGaWVsZFR5cGU7IGNvbXBvbmVudDogVHlwZTx1bmtub3duPiB9Pik6IHZvaWQge1xuICAgICAgICBtYXBwaW5ncy5mb3JFYWNoKCh7IHR5cGUsIGNvbXBvbmVudCB9KSA9PiB0aGlzLnJlZ2lzdGVyRmllbGQodHlwZSwgY29tcG9uZW50KSk7XG4gICAgfVxufVxuIl19

package/esm2022/features/editable-overlay/editable-overlay-editor.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Structural directive used to project a custom editor inside `sdc-editable-overlay`:
+ *
+ * ```html
+ * <sdc-editable-overlay [formControl]="control">
+ *   <ng-template sdcEditableOverlayEditor let-value let-commit="commit">
+ *     <sdc-textarea [value]="value" (valueChange)="commit($event)"></sdc-textarea>
+ *   </ng-template>
+ * </sdc-editable-overlay>
+ * ```
+ *
+ * See `EditableOverlayEditorContext` for the full shape available to the template.
+ */
+export class EditableOverlayEditorDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditableOverlayEditorDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: EditableOverlayEditorDirective, isStandalone: true, selector: "ng-template[sdcEditableOverlayEditor]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditableOverlayEditorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[sdcEditableOverlayEditor]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdGFibGUtb3ZlcmxheS1lZGl0b3IuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL3NyYy9mZWF0dXJlcy9lZGl0YWJsZS1vdmVybGF5L2VkaXRhYmxlLW92ZXJsYXktZWRpdG9yLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFlLE1BQU0sZUFBZSxDQUFDOztBQUl2RDs7Ozs7Ozs7Ozs7O0dBWUc7QUFLSCxNQUFNLE9BQU8sOEJBQThCO0lBQ2I7SUFBNUIsWUFBNEIsUUFBc0Q7UUFBdEQsYUFBUSxHQUFSLFFBQVEsQ0FBOEM7SUFBRyxDQUFDO3dHQUQzRSw4QkFBOEI7NEZBQTlCLDhCQUE4Qjs7NEZBQTlCLDhCQUE4QjtrQkFKMUMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsdUNBQXVDO29CQUNqRCxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB0eXBlIHsgRWRpdGFibGVPdmVybGF5RWRpdG9yQ29udGV4dCB9IGZyb20gJy4uLy4uL2NvcmUvdHlwZXMvZWRpdGFibGUtb3ZlcmxheS50eXBlJztcblxuLyoqXG4gKiBTdHJ1Y3R1cmFsIGRpcmVjdGl2ZSB1c2VkIHRvIHByb2plY3QgYSBjdXN0b20gZWRpdG9yIGluc2lkZSBgc2RjLWVkaXRhYmxlLW92ZXJsYXlgOlxuICpcbiAqIGBgYGh0bWxcbiAqIDxzZGMtZWRpdGFibGUtb3ZlcmxheSBbZm9ybUNvbnRyb2xdPVwiY29udHJvbFwiPlxuICogICA8bmctdGVtcGxhdGUgc2RjRWRpdGFibGVPdmVybGF5RWRpdG9yIGxldC12YWx1ZSBsZXQtY29tbWl0PVwiY29tbWl0XCI+XG4gKiAgICAgPHNkYy10ZXh0YXJlYSBbdmFsdWVdPVwidmFsdWVcIiAodmFsdWVDaGFuZ2UpPVwiY29tbWl0KCRldmVudClcIj48L3NkYy10ZXh0YXJlYT5cbiAqICAgPC9uZy10ZW1wbGF0ZT5cbiAqIDwvc2RjLWVkaXRhYmxlLW92ZXJsYXk+XG4gKiBgYGBcbiAqXG4gKiBTZWUgYEVkaXRhYmxlT3ZlcmxheUVkaXRvckNvbnRleHRgIGZvciB0aGUgZnVsbCBzaGFwZSBhdmFpbGFibGUgdG8gdGhlIHRlbXBsYXRlLlxuICovXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICduZy10ZW1wbGF0ZVtzZGNFZGl0YWJsZU92ZXJsYXlFZGl0b3JdJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBFZGl0YWJsZU92ZXJsYXlFZGl0b3JEaXJlY3RpdmU8VCA9IHVua25vd24+IHtcbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxFZGl0YWJsZU92ZXJsYXlFZGl0b3JDb250ZXh0PFQ+Pikge31cbn1cbiJdfQ==