@dynamic-field-kit/angular 1.2.10 → 1.4.0

package/dist/esm2022/components/DynamicInput.mjs

@@ -1,31 +1,50 @@
 import { CommonModule } from '@angular/common';
-import { Component, Input, Output, EventEmitter, ViewChild, ViewContainerRef, SimpleChange, } from '@angular/core';
-import { fieldRegistry } from '@dynamic-field-kit/core';
+import { ChangeDetectionStrategy, Component, EventEmitter, inject, Input, Output, ViewChild, ViewContainerRef, } from '@angular/core';
+import { FIELD_REGISTRY } from '../fieldRegistryToken';
 import { BaseInputComponent } from './BaseInput';
 import * as i0 from "@angular/core";
+// Only the framework-agnostic FieldRendererProps keys. Domain-specific props
+// reach the renderer through `extraProps` (FieldDescription.props) instead.
+const KNOWN_PROPS = [
+    'value',
+    'label',
+    'placeholder',
+    'required',
+    'disabled',
+    'readOnly',
+    'error',
+    'options',
+    'className',
+    'description',
+];
 export class DynamicInput extends BaseInputComponent {
     type;
+    // Extra, framework-agnostic props forwarded verbatim to the renderer.
+    extraProps;
     valueChange = new EventEmitter();
-    onChange = new EventEmitter(); // backward compat
+    onChange = new EventEmitter();
+    registry = inject(FIELD_REGISTRY);
     host;
     compRef;
     inputInstance;
     subscriptions = [];
+    // Tracks which KNOWN_PROPS were actually supplied to DynamicInput (via
+    // SimpleChanges), independent of TS class-field emit. See applyProps.
+    supplied = new Set();
     ngOnChanges(changes) {
-        if (changes['type'] && !changes['type'].firstChange && this.host) {
-            this.render();
-            return;
+        super.ngOnChanges(changes);
+        for (const prop of KNOWN_PROPS) {
+            if (changes[prop]) {
+                this.supplied.add(prop);
+            }
         }
         if (this.inputInstance) {
-            this.applyKnownProps(this.inputInstance);
-            const childChanges = {};
-            for (const prop in changes) {
-                childChanges[prop] = new SimpleChange(changes[prop].previousValue, changes[prop].currentValue, changes[prop].firstChange);
-            }
-            this.inputInstance.ngOnChanges?.(childChanges);
-            this.compRef?.changeDetectorRef.detectChanges();
+            this.syncPropsToInstance(changes);
+        }
+        if (changes['type'] && !changes['type'].firstChange && this.host) {
+            this.render();
         }
-        else if (this.host) {
+        else if (!this.inputInstance && this.host) {
             this.render();
         }
     }
@@ -33,6 +52,23 @@ export class DynamicInput extends BaseInputComponent {
         this.render();
     }
     ngOnDestroy() {
+        this.cleanup();
+    }
+    syncPropsToInstance(changes) {
+        if (!this.inputInstance) {
+            return;
+        }
+        for (const prop of KNOWN_PROPS) {
+            if (changes[prop] && this.inputInstance) {
+                this.inputInstance[prop] = this[prop];
+            }
+        }
+        if (changes['extraProps']) {
+            this.applyExtraProps(this.inputInstance);
+        }
+        this.compRef?.changeDetectorRef?.detectChanges();
+    }
+    cleanup() {
         this.cleanupSubscriptions();
         this.cleanupRenderedComponent();
     }
@@ -40,106 +76,149 @@ export class DynamicInput extends BaseInputComponent {
         this.subscriptions.forEach((s) => s.unsubscribe());
         this.subscriptions = [];
     }
+    cleanupRenderedComponent() {
+        this.compRef?.destroy();
+        this.compRef = undefined;
+        this.inputInstance = undefined;
+    }
     render() {
-        const Renderer = fieldRegistry.get(this.type);
-        this.cleanupRenderedComponent();
-        this.cleanupSubscriptions();
+        const Renderer = this.registry.get(this.type);
+        this.cleanup();
         this.host.clear();
         if (!Renderer) {
-            const el = document.createElement('div');
-            el.textContent = `Unknown field type: ${this.type}`;
-            this.host.element.nativeElement.appendChild(el);
+            this.renderError(`Unknown field type: ${this.type}`);
             return;
         }
+        if (this.isComponentType(Renderer)) {
+            this.renderComponent(Renderer);
+        }
+        else if (typeof Renderer === 'function') {
+            this.renderFallback(Renderer);
+        }
+        else {
+            this.renderError(`Invalid renderer for type: ${this.type}`);
+        }
+    }
+    // Angular component classes carry a static ɵcmp. Checked instead of
+    // reflectComponentType() because the peer range starts at Angular 13 and
+    // reflectComponentType is v14+. Plain function renderers have no ɵcmp and
+    // fall through to renderFallback. Uses hasOwnProperty (not `in`) so a
+    // class that merely extends a component without its own @Component
+    // decorator - and would otherwise inherit the parent's static ɵcmp via the
+    // prototype chain - is not mistaken for a component in its own right.
+    isComponentType(renderer) {
+        return (typeof renderer === 'function' &&
+            Object.prototype.hasOwnProperty.call(renderer, 'ɵcmp'));
+    }
+    renderComponent(compType) {
         try {
-            const compType = Renderer;
             const compRef = this.host.createComponent(compType);
             const instance = compRef.instance;
             if (!instance) {
-                throw new Error(`Failed to create instance for ${this.type}`);
-            }
-            this.applyKnownProps(instance);
-            const subA = this.bindOutput(instance, 'valueChange');
-            if (subA) {
-                this.subscriptions.push(subA);
-            }
-            const subB = this.bindOutput(instance, 'onValueChange');
-            if (subB) {
-                this.subscriptions.push(subB);
+                this.renderError(`Failed to create instance for ${this.type}`);
+                return;
             }
-            instance.changeDetectorRef?.detectChanges();
+            this.applyProps(instance);
+            this.bindOutputs(instance);
             this.compRef = compRef;
             this.inputInstance = instance;
             compRef.changeDetectorRef.detectChanges();
         }
-        catch (err) {
-            // Fallback to function renderer
-            try {
-                const props = {
-                    value: this.value,
-                    onValueChange: (v) => this.emitValue(v),
-                    label: this.label,
-                    placeholder: this.placeholder,
-                    required: this.required,
-                    options: this.options,
-                    className: this.className,
-                    description: this.description,
-                    disabled: this.disabled,
-                    errorMessage: this.errorMessage,
-                };
-                const out = Renderer(props);
-                if (typeof out === 'string') {
-                    const el = document.createElement('div');
-                    el.innerHTML = out;
-                    this.host.element.nativeElement.appendChild(el);
-                }
-            }
-            catch (e) {
+        catch {
+            this.renderError(`Failed to render field: ${this.type}`);
+        }
+    }
+    renderFallback(renderer) {
+        try {
+            const props = this.getFallbackProps();
+            const result = renderer(props);
+            if (typeof result === 'string') {
                 const el = document.createElement('div');
-                el.textContent = `Failed to render field: ${this.type}`;
+                el.innerHTML = result;
                 this.host.element.nativeElement.appendChild(el);
             }
         }
+        catch {
+            this.renderError(`Failed to render field: ${this.type}`);
+        }
     }
-    applyKnownProps(instance) {
-        const knownProps = [
-            'value',
-            'label',
-            'placeholder',
-            'required',
-            'disabled',
-            'options',
-            'className',
-            'description',
-            'errorMessage',
-        ];
-        for (const prop of knownProps) {
-            if (prop in this && prop in instance) {
-                instance[prop] = this[prop];
+    getFallbackProps() {
+        return {
+            ...this.extraProps,
+            value: this.value,
+            onValueChange: (v) => this.emitValue(v),
+            label: this.label ?? '',
+            placeholder: this.placeholder ?? '',
+            required: this.required ?? false,
+            disabled: this.disabled ?? false,
+            readOnly: this.readOnly ?? false,
+            error: this.error,
+            options: this.options ?? [],
+            className: this.className ?? '',
+            description: this.description ?? '',
+        };
+    }
+    // Gates on `this.supplied` (populated from SimpleChanges in ngOnChanges),
+    // not on `prop in instanceObj` or `prop in this`. Both `in` checks test a
+    // TypeScript class-field emit artifact rather than intent: whether a
+    // property slot exists at runtime depends on the compile target
+    // (useDefineForClassFields is false below ES2022, true at ES2022+), so the
+    // same source can behave oppositely between this package's test build and
+    // its shipped ES2022 bundle, where every declared field is always an own
+    // property. `this.supplied` instead reflects only whether Angular ever
+    // fired a SimpleChange for that input, i.e. whether the prop was *bound*
+    // at all - it skips only props DynamicInput was never given a binding
+    // for. It is NOT a general "renderer defaults survive" guarantee: Angular
+    // fires a firstChange SimpleChange for every bound input even when the
+    // bound value is undefined, and FieldInput's template binds all
+    // KNOWN_PROPS unconditionally, so on the real
+    // MultiFieldInput -> FieldInput -> DynamicInput path every prop counts as
+    // supplied and renderer-side defaults (e.g. `@Input() label = 'None'`)
+    // are still overwritten with undefined. This only helps when DynamicInput
+    // is mounted directly with some inputs left unbound.
+    applyProps(instance) {
+        const instanceObj = instance;
+        for (const prop of KNOWN_PROPS) {
+            if (this.supplied.has(prop)) {
+                instanceObj[prop] = this[prop];
             }
         }
+        this.applyExtraProps(instance);
     }
-    bindOutput(instance, outputName) {
-        const output = instance?.[outputName];
-        if (!output || typeof output.subscribe !== 'function') {
+    applyExtraProps(instance) {
+        if (!instance || !this.extraProps) {
             return;
         }
-        const sub = output.subscribe((value) => {
-            this.emitValue(value);
-        });
-        return sub;
+        const instanceObj = instance;
+        for (const [key, value] of Object.entries(this.extraProps)) {
+            instanceObj[key] = value;
+        }
+    }
+    bindOutputs(instance) {
+        const outputNames = [
+            'valueChange',
+            'onValueChange',
+        ];
+        for (const outputName of outputNames) {
+            const output = instance[outputName];
+            if (output && typeof output === 'object' && 'subscribe' in output) {
+                const sub = output.subscribe((value) => this.emitValue(value));
+                this.subscriptions.push(sub);
+            }
+        }
     }
     emitValue(value) {
         this.valueChange.emit(value);
         this.onChange.emit(value);
     }
-    cleanupRenderedComponent() {
-        this.compRef?.destroy();
-        this.compRef = undefined;
-        this.inputInstance = undefined;
+    renderError(message) {
+        const el = document.createElement('div');
+        el.textContent = message;
+        el.style.color = 'red';
+        this.host.element.nativeElement.appendChild(el);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: DynamicInput, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: DynamicInput, isStandalone: true, selector: "dfk-dynamic-input", inputs: { type: "type" }, outputs: { valueChange: "valueChange", onChange: "onChange" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, read: ViewContainerRef }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `<div #host style="display: contents;"></div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: DynamicInput, isStandalone: true, selector: "dfk-dynamic-input", inputs: { type: "type", extraProps: "extraProps" }, outputs: { valueChange: "valueChange", onChange: "onChange" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, read: ViewContainerRef }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `<div #host style="display: contents;"></div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: DynamicInput, decorators: [{
             type: Component,
@@ -147,10 +226,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                     selector: 'dfk-dynamic-input',
                     standalone: true,
                     imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
                     template: `<div #host style="display: contents;"></div>`,
                 }]
         }], propDecorators: { type: [{
                 type: Input
+            }], extraProps: [{
+                type: Input
             }], valueChange: [{
                 type: Output
             }], onChange: [{
@@ -159,4 +241,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                 type: ViewChild,
                 args: ['host', { read: ViewContainerRef, static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DynamicInput.js","sourceRoot":"","sources":["../../../src/components/DynamicInput.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component,\n  ComponentRef,\n  Input,\n  Output,\n  EventEmitter,\n  ViewChild,\n  ViewContainerRef,\n  OnChanges,\n  AfterViewInit,\n  OnDestroy,\n  SimpleChanges,\n  Type,\n  SimpleChange,\n} from '@angular/core';\nimport { fieldRegistry, FieldTypeKey } from '@dynamic-field-kit/core';\nimport { Subscription } from 'rxjs';\nimport { BaseInputComponent } from './BaseInput';\n\n@Component({\n  selector: 'dfk-dynamic-input',\n  standalone: true,\n  imports: [CommonModule],\n  template: `<div #host style=\"display: contents;\"></div>`,\n})\nexport class DynamicInput\n  extends BaseInputComponent\n  implements OnChanges, AfterViewInit, OnDestroy\n{\n  @Input() type!: FieldTypeKey;\n  @Output() override valueChange = new EventEmitter<any>();\n  @Output() onChange = new EventEmitter<any>(); // backward compat\n\n  @ViewChild('host', { read: ViewContainerRef, static: false })\n  host!: ViewContainerRef;\n  private compRef?: ComponentRef<any>;\n  private inputInstance?: any;\n  private subscriptions: Subscription[] = [];\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['type'] && !changes['type'].firstChange && this.host) {\n      this.render();\n      return;\n    }\n\n    if (this.inputInstance) {\n      this.applyKnownProps(this.inputInstance);\n\n      const childChanges: SimpleChanges = {};\n      for (const prop in changes) {\n        childChanges[prop] = new SimpleChange(\n          changes[prop].previousValue,\n          changes[prop].currentValue,\n          changes[prop].firstChange\n        );\n      }\n\n      this.inputInstance.ngOnChanges?.(childChanges);\n      this.compRef?.changeDetectorRef.detectChanges();\n    } else if (this.host) {\n      this.render();\n    }\n  }\n\n  ngAfterViewInit() {\n    this.render();\n  }\n\n  ngOnDestroy() {\n    this.cleanupSubscriptions();\n    this.cleanupRenderedComponent();\n  }\n\n  private cleanupSubscriptions() {\n    this.subscriptions.forEach((s) => s.unsubscribe());\n    this.subscriptions = [];\n  }\n\n  private render() {\n    const Renderer = fieldRegistry.get(this.type as FieldTypeKey);\n    this.cleanupRenderedComponent();\n    this.cleanupSubscriptions();\n    this.host.clear();\n    if (!Renderer) {\n      const el = document.createElement('div');\n      el.textContent = `Unknown field type: ${this.type}`;\n      this.host.element.nativeElement.appendChild(el);\n      return;\n    }\n\n    try {\n      const compType = Renderer as unknown as Type<any>;\n      const compRef = this.host.createComponent(compType);\n      const instance = compRef.instance;\n      if (!instance) {\n        throw new Error(`Failed to create instance for ${this.type}`);\n      }\n\n      this.applyKnownProps(instance);\n\n      const subA = this.bindOutput(instance, 'valueChange');\n      if (subA) {\n        this.subscriptions.push(subA);\n      }\n      const subB = this.bindOutput(instance, 'onValueChange');\n      if (subB) {\n        this.subscriptions.push(subB);\n      }\n\n      instance.changeDetectorRef?.detectChanges();\n      this.compRef = compRef;\n      this.inputInstance = instance;\n      compRef.changeDetectorRef.detectChanges();\n    } catch (err) {\n      // Fallback to function renderer\n      try {\n        const props: any = {\n          value: this.value,\n          onValueChange: (v: any) => this.emitValue(v),\n          label: this.label,\n          placeholder: this.placeholder,\n          required: this.required,\n          options: this.options,\n          className: this.className,\n          description: this.description,\n          disabled: this.disabled,\n          errorMessage: this.errorMessage,\n        };\n        const out = (Renderer as (props: unknown) => unknown)(props);\n        if (typeof out === 'string') {\n          const el = document.createElement('div');\n          el.innerHTML = out;\n          this.host.element.nativeElement.appendChild(el);\n        }\n      } catch (e) {\n        const el = document.createElement('div');\n        el.textContent = `Failed to render field: ${this.type}`;\n        this.host.element.nativeElement.appendChild(el);\n      }\n    }\n  }\n\n  private applyKnownProps(instance: any) {\n    const knownProps = [\n      'value',\n      'label',\n      'placeholder',\n      'required',\n      'disabled',\n      'options',\n      'className',\n      'description',\n      'errorMessage',\n    ];\n    for (const prop of knownProps) {\n      if (prop in this && prop in instance) {\n        instance[prop] = (this as any)[prop];\n      }\n    }\n  }\n\n  private bindOutput(\n    instance: any,\n    outputName: 'valueChange' | 'onValueChange'\n  ): Subscription | undefined {\n    const output = instance?.[outputName];\n    if (!output || typeof output.subscribe !== 'function') {\n      return;\n    }\n\n    const sub = (output as EventEmitter<any>).subscribe((value) => {\n      this.emitValue(value);\n    });\n    return sub;\n  }\n\n  private emitValue(value: any) {\n    this.valueChange.emit(value);\n    this.onChange.emit(value);\n  }\n\n  private cleanupRenderedComponent() {\n    this.compRef?.destroy();\n    this.compRef = undefined;\n    this.inputInstance = undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DynamicInput.js","sourceRoot":"","sources":["../../../src/components/DynamicInput.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ComponentRef,\n  EventEmitter,\n  inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  Type,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { FieldTypeKey, Properties } from '@dynamic-field-kit/core';\nimport { Subscription } from 'rxjs';\nimport { FIELD_REGISTRY } from '../fieldRegistryToken';\nimport { BaseInputComponent } from './BaseInput';\n\n// Only the framework-agnostic FieldRendererProps keys. Domain-specific props\n// reach the renderer through `extraProps` (FieldDescription.props) instead.\nconst KNOWN_PROPS = [\n  'value',\n  'label',\n  'placeholder',\n  'required',\n  'disabled',\n  'readOnly',\n  'error',\n  'options',\n  'className',\n  'description',\n] as const;\n\n@Component({\n  selector: 'dfk-dynamic-input',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div #host style=\"display: contents;\"></div>`,\n})\nexport class DynamicInput\n  extends BaseInputComponent\n  implements OnChanges, AfterViewInit, OnDestroy\n{\n  @Input() type!: FieldTypeKey;\n  // Extra, framework-agnostic props forwarded verbatim to the renderer.\n  @Input() extraProps?: Properties;\n  @Output() override valueChange = new EventEmitter<unknown>();\n  @Output() onChange = new EventEmitter<unknown>();\n\n  private registry = inject(FIELD_REGISTRY);\n\n  @ViewChild('host', { read: ViewContainerRef, static: false })\n  host!: ViewContainerRef;\n  private compRef?: ComponentRef<unknown>;\n  private inputInstance?: unknown;\n  private subscriptions: Subscription[] = [];\n  // Tracks which KNOWN_PROPS were actually supplied to DynamicInput (via\n  // SimpleChanges), independent of TS class-field emit. See applyProps.\n  private supplied = new Set<string>();\n\n  ngOnChanges(changes: SimpleChanges): void {\n    super.ngOnChanges(changes);\n\n    for (const prop of KNOWN_PROPS) {\n      if (changes[prop]) {\n        this.supplied.add(prop);\n      }\n    }\n\n    if (this.inputInstance) {\n      this.syncPropsToInstance(changes);\n    }\n\n    if (changes['type'] && !changes['type'].firstChange && this.host) {\n      this.render();\n    } else if (!this.inputInstance && this.host) {\n      this.render();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.render();\n  }\n\n  ngOnDestroy(): void {\n    this.cleanup();\n  }\n\n  private syncPropsToInstance(changes: SimpleChanges): void {\n    if (!this.inputInstance) {\n      return;\n    }\n\n    for (const prop of KNOWN_PROPS) {\n      if (changes[prop] && this.inputInstance) {\n        (this.inputInstance as Record<string, unknown>)[prop] = (\n          this as Record<string, unknown>\n        )[prop];\n      }\n    }\n    if (changes['extraProps']) {\n      this.applyExtraProps(this.inputInstance);\n    }\n    this.compRef?.changeDetectorRef?.detectChanges();\n  }\n\n  private cleanup(): void {\n    this.cleanupSubscriptions();\n    this.cleanupRenderedComponent();\n  }\n\n  private cleanupSubscriptions(): void {\n    this.subscriptions.forEach((s) => s.unsubscribe());\n    this.subscriptions = [];\n  }\n\n  private cleanupRenderedComponent(): void {\n    this.compRef?.destroy();\n    this.compRef = undefined;\n    this.inputInstance = undefined;\n  }\n\n  private render(): void {\n    const Renderer = this.registry.get(this.type);\n    this.cleanup();\n    this.host.clear();\n\n    if (!Renderer) {\n      this.renderError(`Unknown field type: ${this.type}`);\n      return;\n    }\n\n    if (this.isComponentType(Renderer)) {\n      this.renderComponent(Renderer as unknown as Type<unknown>);\n    } else if (typeof Renderer === 'function') {\n      this.renderFallback(Renderer);\n    } else {\n      this.renderError(`Invalid renderer for type: ${this.type}`);\n    }\n  }\n\n  // Angular component classes carry a static ɵcmp. Checked instead of\n  // reflectComponentType() because the peer range starts at Angular 13 and\n  // reflectComponentType is v14+. Plain function renderers have no ɵcmp and\n  // fall through to renderFallback. Uses hasOwnProperty (not `in`) so a\n  // class that merely extends a component without its own @Component\n  // decorator - and would otherwise inherit the parent's static ɵcmp via the\n  // prototype chain - is not mistaken for a component in its own right.\n  private isComponentType(renderer: unknown): boolean {\n    return (\n      typeof renderer === 'function' &&\n      Object.prototype.hasOwnProperty.call(renderer, 'ɵcmp')\n    );\n  }\n\n  private renderComponent(compType: Type<unknown>): void {\n    try {\n      const compRef = this.host.createComponent(compType);\n      const instance = compRef.instance;\n\n      if (!instance) {\n        this.renderError(`Failed to create instance for ${this.type}`);\n        return;\n      }\n\n      this.applyProps(instance);\n      this.bindOutputs(instance);\n\n      this.compRef = compRef;\n      this.inputInstance = instance;\n      compRef.changeDetectorRef.detectChanges();\n    } catch {\n      this.renderError(`Failed to render field: ${this.type}`);\n    }\n  }\n\n  private renderFallback(renderer: unknown): void {\n    try {\n      const props = this.getFallbackProps();\n      const result = (renderer as (props: unknown) => string)(props);\n\n      if (typeof result === 'string') {\n        const el = document.createElement('div');\n        el.innerHTML = result;\n        this.host.element.nativeElement.appendChild(el);\n      }\n    } catch {\n      this.renderError(`Failed to render field: ${this.type}`);\n    }\n  }\n\n  private getFallbackProps(): Record<string, unknown> {\n    return {\n      ...this.extraProps,\n      value: this.value,\n      onValueChange: (v: unknown) => this.emitValue(v),\n      label: this.label ?? '',\n      placeholder: this.placeholder ?? '',\n      required: this.required ?? false,\n      disabled: this.disabled ?? false,\n      readOnly: this.readOnly ?? false,\n      error: this.error,\n      options: this.options ?? [],\n      className: this.className ?? '',\n      description: this.description ?? '',\n    };\n  }\n\n  // Gates on `this.supplied` (populated from SimpleChanges in ngOnChanges),\n  // not on `prop in instanceObj` or `prop in this`. Both `in` checks test a\n  // TypeScript class-field emit artifact rather than intent: whether a\n  // property slot exists at runtime depends on the compile target\n  // (useDefineForClassFields is false below ES2022, true at ES2022+), so the\n  // same source can behave oppositely between this package's test build and\n  // its shipped ES2022 bundle, where every declared field is always an own\n  // property. `this.supplied` instead reflects only whether Angular ever\n  // fired a SimpleChange for that input, i.e. whether the prop was *bound*\n  // at all - it skips only props DynamicInput was never given a binding\n  // for. It is NOT a general \"renderer defaults survive\" guarantee: Angular\n  // fires a firstChange SimpleChange for every bound input even when the\n  // bound value is undefined, and FieldInput's template binds all\n  // KNOWN_PROPS unconditionally, so on the real\n  // MultiFieldInput -> FieldInput -> DynamicInput path every prop counts as\n  // supplied and renderer-side defaults (e.g. `@Input() label = 'None'`)\n  // are still overwritten with undefined. This only helps when DynamicInput\n  // is mounted directly with some inputs left unbound.\n  private applyProps(instance: unknown): void {\n    const instanceObj = instance as Record<string, unknown>;\n    for (const prop of KNOWN_PROPS) {\n      if (this.supplied.has(prop)) {\n        instanceObj[prop] = (this as Record<string, unknown>)[prop];\n      }\n    }\n    this.applyExtraProps(instance);\n  }\n\n  private applyExtraProps(instance: unknown): void {\n    if (!instance || !this.extraProps) {\n      return;\n    }\n    const instanceObj = instance as Record<string, unknown>;\n    for (const [key, value] of Object.entries(this.extraProps)) {\n      instanceObj[key] = value;\n    }\n  }\n\n  private bindOutputs(instance: unknown): void {\n    const outputNames: Array<'valueChange' | 'onValueChange'> = [\n      'valueChange',\n      'onValueChange',\n    ];\n\n    for (const outputName of outputNames) {\n      const output = (instance as Record<string, unknown>)[outputName];\n      if (output && typeof output === 'object' && 'subscribe' in output) {\n        const sub = (\n          output as { subscribe: (cb: (v: unknown) => void) => Subscription }\n        ).subscribe((value: unknown) => this.emitValue(value));\n        this.subscriptions.push(sub);\n      }\n    }\n  }\n\n  private emitValue(value: unknown): void {\n    this.valueChange.emit(value);\n    this.onChange.emit(value);\n  }\n\n  private renderError(message: string): void {\n    const el = document.createElement('div');\n    el.textContent = message;\n    el.style.color = 'red';\n    this.host.element.nativeElement.appendChild(el);\n  }\n}\n"]}

package/dist/esm2022/components/FieldInput.mjs

@@ -1,40 +1,57 @@
 import { NgIf } from '@angular/common';
-import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
 import { DynamicInput } from './DynamicInput';
 import * as i0 from "@angular/core";
 export class FieldInput {
+    cdr;
     fieldDescription;
-    renderInfos;
+    value;
+    options;
+    disabled;
+    readOnly;
+    error;
     onValueChangeField = new EventEmitter();
-    getFieldValue() {
-        if (!this.fieldDescription || !this.renderInfos) {
+    shouldRender = false;
+    get resolvedOptions() {
+        if (this.options) {
+            return this.options;
+        }
+        if (!this.fieldDescription?.options) {
             return undefined;
         }
-        const value = this.renderInfos[this.fieldDescription.name];
-        if (value === undefined && this.fieldDescription.type === 'text') {
-            return '';
+        if (typeof this.fieldDescription.options === 'function') {
+            return undefined;
         }
-        return value;
+        return this.fieldDescription.options;
+    }
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngOnChanges(_changes) {
+        this.shouldRender = !!this.fieldDescription;
+        this.cdr.markForCheck();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: FieldInput, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: FieldInput, isStandalone: true, selector: "dfk-field-input", inputs: { fieldDescription: "fieldDescription", renderInfos: "renderInfos" }, outputs: { onValueChangeField: "onValueChangeField" }, ngImport: i0, template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: FieldInput, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: FieldInput, isStandalone: true, selector: "dfk-field-input", inputs: { fieldDescription: "fieldDescription", value: "value", options: "options", disabled: "disabled", readOnly: "readOnly", error: "error" }, outputs: { onValueChangeField: "onValueChangeField" }, usesOnChanges: true, ngImport: i0, template: `
     <dfk-dynamic-input
-      *ngIf="fieldDescription && renderInfos"
+      *ngIf="shouldRender"
       [type]="fieldDescription!.type"
-      [value]="getFieldValue()"
+      [value]="value"
       [label]="fieldDescription!.label"
       [placeholder]="fieldDescription!.placeholder"
       [required]="fieldDescription!.required"
-      [description]="fieldDescription!.description"
-      [options]="fieldDescription!.options"
+      [description]="$any(fieldDescription!.description)"
+      [options]="resolvedOptions"
       [className]="fieldDescription!.className"
       (valueChange)="
         onValueChangeField.emit({ value: $event, key: fieldDescription!.name })
       "
-      [disabled]="false"
-      [errorMessage]="''"
+      [disabled]="disabled"
+      [readOnly]="readOnly"
+      [error]="$any(error)"
+      [extraProps]="fieldDescription!.props"
     ></dfk-dynamic-input>
-  `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: DynamicInput, selector: "dfk-dynamic-input", inputs: ["type"], outputs: ["valueChange", "onChange"] }] });
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: DynamicInput, selector: "dfk-dynamic-input", inputs: ["type", "extraProps"], outputs: ["valueChange", "onChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: FieldInput, decorators: [{
             type: Component,
@@ -42,30 +59,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                     selector: 'dfk-field-input',
                     standalone: true,
                     imports: [NgIf, DynamicInput],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
                     template: `
     <dfk-dynamic-input
-      *ngIf="fieldDescription && renderInfos"
+      *ngIf="shouldRender"
       [type]="fieldDescription!.type"
-      [value]="getFieldValue()"
+      [value]="value"
       [label]="fieldDescription!.label"
       [placeholder]="fieldDescription!.placeholder"
       [required]="fieldDescription!.required"
-      [description]="fieldDescription!.description"
-      [options]="fieldDescription!.options"
+      [description]="$any(fieldDescription!.description)"
+      [options]="resolvedOptions"
       [className]="fieldDescription!.className"
       (valueChange)="
         onValueChangeField.emit({ value: $event, key: fieldDescription!.name })
       "
-      [disabled]="false"
-      [errorMessage]="''"
+      [disabled]="disabled"
+      [readOnly]="readOnly"
+      [error]="$any(error)"
+      [extraProps]="fieldDescription!.props"
     ></dfk-dynamic-input>
   `,
                 }]
-        }], propDecorators: { fieldDescription: [{
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { fieldDescription: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], readOnly: [{
                 type: Input
-            }], renderInfos: [{
+            }], error: [{
                 type: Input
             }], onValueChangeField: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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