@dynamic-field-kit/angular 1.2.10 → 1.4.0

package/dist/esm2022/components/MultiFieldInput.mjs

@@ -1,85 +1,338 @@
-import { NgClass, NgFor } from '@angular/common';
-import { Component, Input, Output, EventEmitter, } from '@angular/core';
+import { NgClass, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+import { applyComputedValues, canAddGroupItem, canRemoveGroupItem, createGroupItem, resolveDisabled, resolveOptions, resolveReadOnly, validateField, validateFields, } from '@dynamic-field-kit/core';
 import { FieldInput } from './FieldInput';
 import * as i0 from "@angular/core";
+const DEFAULT_BREAKPOINT = 768;
 export class MultiFieldInput {
+    cdr;
     fieldDescriptions = [];
     properties;
     onChange = new EventEmitter();
+    validityChange = new EventEmitter();
     layout = 'column';
+    // Top-level form data, threaded down through repeatable groups so a nested
+    // field's appearCondition/computeValue can read the root form. Omitted at
+    // the top level, where the form's own data is the root.
+    rootData;
     data = {};
     visibleFields = [];
+    isMobile = false;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    onWindowResize() {
+        const wasMobile = this.isMobile;
+        this.updateIsMobile();
+        if (wasMobile !== this.isMobile) {
+            this.cdr.markForCheck();
+        }
+    }
+    get resolvedLayout() {
+        if (typeof this.layout === 'object' && this.layout.type === 'responsive') {
+            return this.isMobile ? this.layout.mobile : this.layout.desktop;
+        }
+        return this.layout;
+    }
+    get resolvedLayoutType() {
+        const resolved = this.resolvedLayout;
+        return typeof resolved === 'string' ? resolved : resolved.type;
+    }
+    get gap() {
+        const resolved = this.resolvedLayout;
+        if (typeof resolved === 'object' && resolved.gap !== undefined) {
+            return resolved.gap;
+        }
+        return 12;
+    }
+    get columns() {
+        const resolved = this.resolvedLayout;
+        if (typeof resolved === 'object' && resolved.type === 'grid') {
+            return resolved.columns ?? 2;
+        }
+        return 2;
+    }
     trackByFn(index, field) {
         return field.name || index;
     }
+    trackByIndex(index) {
+        return index;
+    }
+    groupTrackByCache = new WeakMap();
+    // Returns a stable trackBy per group field: item[keyField] when configured,
+    // else the index. Cached by field reference so the template hands Angular the
+    // same function each change-detection pass.
+    groupTrackBy(field) {
+        let fn = this.groupTrackByCache.get(field);
+        if (!fn) {
+            fn = (index, item) => field.keyField ? item[field.keyField] ?? index : index;
+            this.groupTrackByCache.set(field, fn);
+        }
+        return fn;
+    }
     ngOnInit() {
+        this.updateIsMobile();
         this.init();
     }
     ngOnChanges(_changes) {
         this.init();
     }
+    updateIsMobile() {
+        const breakpoint = typeof this.layout === 'object' && this.layout.type === 'responsive'
+            ? this.layout.breakpoint ?? DEFAULT_BREAKPOINT
+            : DEFAULT_BREAKPOINT;
+        if (typeof window !== 'undefined' &&
+            typeof window.matchMedia === 'function') {
+            this.isMobile = window.matchMedia(`(max-width: ${breakpoint - 1}px)`).matches;
+        }
+        else {
+            this.isMobile =
+                typeof window !== 'undefined' && window.innerWidth < breakpoint;
+        }
+    }
     init() {
         if (this.properties) {
-            this.data = { ...this.properties };
+            this.data = applyComputedValues(this.fieldDescriptions, { ...this.properties }, this.rootData);
         }
         this.updateVisibleFields();
+        this.validityChange.emit(validateFields(this.fieldDescriptions, this.data, this.rootData));
     }
     updateVisibleFields() {
-        this.visibleFields = this.fieldDescriptions.filter((f) => !f.appearCondition || f.appearCondition(this.data));
+        const root = this.rootData ?? this.data;
+        this.visibleFields = this.fieldDescriptions.filter((f) => !f.appearCondition || f.appearCondition(this.data, root));
     }
     onFieldChange(event) {
-        this.data = { ...this.data, [event.key]: event.value };
+        this.commitData({ ...this.data, [event.key]: event.value });
+    }
+    getItems(field) {
+        const value = this.data[field.name];
+        return Array.isArray(value) ? value : [];
+    }
+    getResolvedOptions(field) {
+        return resolveOptions(field, this.data, this.rootData);
+    }
+    getDisabled(field) {
+        return resolveDisabled(field, this.data, this.rootData);
+    }
+    getReadOnly(field) {
+        return resolveReadOnly(field, this.data, this.rootData);
+    }
+    getError(field) {
+        if (this.getDisabled(field)) {
+            return undefined;
+        }
+        const errors = validateField(field, this.data[field.name], this.data, this.rootData);
+        return errors.length > 0 ? errors : undefined;
+    }
+    canAddItem(field) {
+        return canAddGroupItem(field, this.getItems(field));
+    }
+    canRemoveItem(field) {
+        return canRemoveGroupItem(field, this.getItems(field));
+    }
+    onGroupItemAdd(field) {
+        if (!this.canAddItem(field)) {
+            return;
+        }
+        const items = this.getItems(field);
+        this.commitData({
+            ...this.data,
+            [field.name]: [...items, createGroupItem(field)],
+        });
+    }
+    onGroupItemRemove(field, index) {
+        if (!this.canRemoveItem(field)) {
+            return;
+        }
+        const items = this.getItems(field).filter((_, i) => i !== index);
+        this.commitData({ ...this.data, [field.name]: items });
+    }
+    onGroupItemChange(field, index, next) {
+        const items = this.getItems(field).slice();
+        items[index] = next;
+        this.commitData({ ...this.data, [field.name]: items });
+    }
+    commitData(nextData) {
+        this.data = applyComputedValues(this.fieldDescriptions, nextData, this.rootData);
         this.updateVisibleFields();
         this.onChange.emit(this.data);
+        this.validityChange.emit(validateFields(this.fieldDescriptions, this.data, this.rootData));
+        this.cdr.markForCheck();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: MultiFieldInput, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: MultiFieldInput, isStandalone: true, selector: "dfk-multi-field-input", inputs: { fieldDescriptions: "fieldDescriptions", properties: "properties", layout: "layout" }, outputs: { onChange: "onChange" }, usesOnChanges: true, ngImport: i0, template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: MultiFieldInput, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: MultiFieldInput, isStandalone: true, selector: "dfk-multi-field-input", inputs: { fieldDescriptions: "fieldDescriptions", properties: "properties", layout: "layout", rootData: "rootData" }, outputs: { onChange: "onChange", validityChange: "validityChange" }, host: { listeners: { "window:resize": "onWindowResize()" } }, usesOnChanges: true, ngImport: i0, template: `
     <div
-      class="flex flex-col gap-3 p-4 border rounded-lg bg-gray-50"
+      class="p-4 border rounded-lg bg-gray-50"
       [ngClass]="{
-        'flex-row gap-3': layout === 'row',
-        'grid grid-cols-2 gap-3': layout === 'grid'
+        'flex flex-col': resolvedLayoutType === 'column',
+        'flex flex-row': resolvedLayoutType === 'row',
+        grid: resolvedLayoutType === 'grid'
       }"
+      [style.gap.px]="gap"
+      [style.gridTemplateColumns]="
+        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null
+      "
     >
-      <dfk-field-input
-        *ngFor="let field of visibleFields; trackBy: trackByFn"
-        [fieldDescription]="field"
-        [renderInfos]="data"
-        (onValueChangeField)="onFieldChange($event)"
-      ></dfk-field-input>
+      <ng-container *ngFor="let field of visibleFields; trackBy: trackByFn">
+        <dfk-field-input
+          *ngIf="!field.fields"
+          [fieldDescription]="field"
+          [value]="data[field.name]"
+          [options]="getResolvedOptions(field)"
+          [disabled]="getDisabled(field)"
+          [readOnly]="getReadOnly(field)"
+          [error]="getError(field)"
+          (onValueChangeField)="onFieldChange($event)"
+        ></dfk-field-input>
+
+        <div *ngIf="field.fields" [class]="field.className">
+          <div *ngIf="field.label">{{ field.label }}</div>
+          <div
+            *ngFor="
+              let item of getItems(field);
+              let i = index;
+              trackBy: groupTrackBy(field)
+            "
+            style="display: flex; align-items: flex-start; gap: 8px;"
+          >
+            <div style="flex: 1">
+              <dfk-multi-field-input
+                [fieldDescriptions]="field.fields"
+                [properties]="item"
+                [rootData]="rootData ?? data"
+                (onChange)="onGroupItemChange(field, i, $event)"
+              ></dfk-multi-field-input>
+            </div>
+            <button
+              type="button"
+              [attr.aria-label]="
+                (field.removeLabel || 'Remove') +
+                ' ' +
+                (field.label || field.name) +
+                ' ' +
+                (i + 1)
+              "
+              (click)="onGroupItemRemove(field, i)"
+              [disabled]="!canRemoveItem(field)"
+            >
+              {{ field.removeLabel || 'Remove' }}
+            </button>
+          </div>
+          <button
+            type="button"
+            [attr.aria-label]="
+              (field.addLabel || 'Add') + ' ' + (field.label || field.name)
+            "
+            (click)="onGroupItemAdd(field)"
+            [disabled]="!canAddItem(field)"
+          >
+            {{ field.addLabel || 'Add' }}
+          </button>
+        </div>
+      </ng-container>
     </div>
-  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: FieldInput, selector: "dfk-field-input", inputs: ["fieldDescription", "renderInfos"], outputs: ["onValueChangeField"] }] });
+  `, isInline: true, dependencies: [{ kind: "component", type: MultiFieldInput, selector: "dfk-multi-field-input", inputs: ["fieldDescriptions", "properties", "layout", "rootData"], outputs: ["onChange", "validityChange"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FieldInput, selector: "dfk-field-input", inputs: ["fieldDescription", "value", "options", "disabled", "readOnly", "error"], outputs: ["onValueChangeField"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: MultiFieldInput, decorators: [{
             type: Component,
             args: [{
                     selector: 'dfk-multi-field-input',
                     standalone: true,
-                    imports: [NgClass, NgFor, FieldInput],
+                    // Repeatable field groups render a nested <dfk-multi-field-input> per item
+                    // (see the #groupTpl below), so this component imports itself. That's the
+                    // supported way to give a standalone component recursive template usage
+                    // without a cross-file circular import between FieldInput and a separate
+                    // group component (whose `imports` arrays are evaluated eagerly at module
+                    // load time and would deadlock on an actual circular module reference).
+                    imports: [NgClass, NgFor, NgIf, FieldInput, MultiFieldInput],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
                     template: `
     <div
-      class="flex flex-col gap-3 p-4 border rounded-lg bg-gray-50"
+      class="p-4 border rounded-lg bg-gray-50"
       [ngClass]="{
-        'flex-row gap-3': layout === 'row',
-        'grid grid-cols-2 gap-3': layout === 'grid'
+        'flex flex-col': resolvedLayoutType === 'column',
+        'flex flex-row': resolvedLayoutType === 'row',
+        grid: resolvedLayoutType === 'grid'
       }"
+      [style.gap.px]="gap"
+      [style.gridTemplateColumns]="
+        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null
+      "
     >
-      <dfk-field-input
-        *ngFor="let field of visibleFields; trackBy: trackByFn"
-        [fieldDescription]="field"
-        [renderInfos]="data"
-        (onValueChangeField)="onFieldChange($event)"
-      ></dfk-field-input>
+      <ng-container *ngFor="let field of visibleFields; trackBy: trackByFn">
+        <dfk-field-input
+          *ngIf="!field.fields"
+          [fieldDescription]="field"
+          [value]="data[field.name]"
+          [options]="getResolvedOptions(field)"
+          [disabled]="getDisabled(field)"
+          [readOnly]="getReadOnly(field)"
+          [error]="getError(field)"
+          (onValueChangeField)="onFieldChange($event)"
+        ></dfk-field-input>
+
+        <div *ngIf="field.fields" [class]="field.className">
+          <div *ngIf="field.label">{{ field.label }}</div>
+          <div
+            *ngFor="
+              let item of getItems(field);
+              let i = index;
+              trackBy: groupTrackBy(field)
+            "
+            style="display: flex; align-items: flex-start; gap: 8px;"
+          >
+            <div style="flex: 1">
+              <dfk-multi-field-input
+                [fieldDescriptions]="field.fields"
+                [properties]="item"
+                [rootData]="rootData ?? data"
+                (onChange)="onGroupItemChange(field, i, $event)"
+              ></dfk-multi-field-input>
+            </div>
+            <button
+              type="button"
+              [attr.aria-label]="
+                (field.removeLabel || 'Remove') +
+                ' ' +
+                (field.label || field.name) +
+                ' ' +
+                (i + 1)
+              "
+              (click)="onGroupItemRemove(field, i)"
+              [disabled]="!canRemoveItem(field)"
+            >
+              {{ field.removeLabel || 'Remove' }}
+            </button>
+          </div>
+          <button
+            type="button"
+            [attr.aria-label]="
+              (field.addLabel || 'Add') + ' ' + (field.label || field.name)
+            "
+            (click)="onGroupItemAdd(field)"
+            [disabled]="!canAddItem(field)"
+          >
+            {{ field.addLabel || 'Add' }}
+          </button>
+        </div>
+      </ng-container>
     </div>
   `,
                 }]
-        }], propDecorators: { fieldDescriptions: [{
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { fieldDescriptions: [{
                 type: Input
             }], properties: [{
                 type: Input
             }], onChange: [{
                 type: Output
+            }], validityChange: [{
+                type: Output
             }], layout: [{
                 type: Input
+            }], rootData: [{
+                type: Input
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MultiFieldInput.js","sourceRoot":"","sources":["../../../src/components/MultiFieldInput.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport {\n  applyComputedValues,\n  canAddGroupItem,\n  canRemoveGroupItem,\n  createGroupItem,\n  resolveDisabled,\n  resolveOptions,\n  resolveReadOnly,\n  validateField,\n  validateFields,\n  FieldDescription,\n  Properties,\n} from '@dynamic-field-kit/core';\nimport type { ValidationResult } from '@dynamic-field-kit/core';\nimport { BaseLayoutConfig, LayoutConfig } from '../types/layout';\nimport { FieldInput } from './FieldInput';\n\nconst DEFAULT_BREAKPOINT = 768;\n\n@Component({\n  selector: 'dfk-multi-field-input',\n  standalone: true,\n  // Repeatable field groups render a nested <dfk-multi-field-input> per item\n  // (see the #groupTpl below), so this component imports itself. That's the\n  // supported way to give a standalone component recursive template usage\n  // without a cross-file circular import between FieldInput and a separate\n  // group component (whose `imports` arrays are evaluated eagerly at module\n  // load time and would deadlock on an actual circular module reference).\n  imports: [NgClass, NgFor, NgIf, FieldInput, MultiFieldInput],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      class=\"p-4 border rounded-lg bg-gray-50\"\n      [ngClass]=\"{\n        'flex flex-col': resolvedLayoutType === 'column',\n        'flex flex-row': resolvedLayoutType === 'row',\n        grid: resolvedLayoutType === 'grid'\n      }\"\n      [style.gap.px]=\"gap\"\n      [style.gridTemplateColumns]=\"\n        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null\n      \"\n    >\n      <ng-container *ngFor=\"let field of visibleFields; trackBy: trackByFn\">\n        <dfk-field-input\n          *ngIf=\"!field.fields\"\n          [fieldDescription]=\"field\"\n          [value]=\"data[field.name]\"\n          [options]=\"getResolvedOptions(field)\"\n          [disabled]=\"getDisabled(field)\"\n          [readOnly]=\"getReadOnly(field)\"\n          [error]=\"getError(field)\"\n          (onValueChangeField)=\"onFieldChange($event)\"\n        ></dfk-field-input>\n\n        <div *ngIf=\"field.fields\" [class]=\"field.className\">\n          <div *ngIf=\"field.label\">{{ field.label }}</div>\n          <div\n            *ngFor=\"\n              let item of getItems(field);\n              let i = index;\n              trackBy: groupTrackBy(field)\n            \"\n            style=\"display: flex; align-items: flex-start; gap: 8px;\"\n          >\n            <div style=\"flex: 1\">\n              <dfk-multi-field-input\n                [fieldDescriptions]=\"field.fields\"\n                [properties]=\"item\"\n                [rootData]=\"rootData ?? data\"\n                (onChange)=\"onGroupItemChange(field, i, $event)\"\n              ></dfk-multi-field-input>\n            </div>\n            <button\n              type=\"button\"\n              [attr.aria-label]=\"\n                (field.removeLabel || 'Remove') +\n                ' ' +\n                (field.label || field.name) +\n                ' ' +\n                (i + 1)\n              \"\n              (click)=\"onGroupItemRemove(field, i)\"\n              [disabled]=\"!canRemoveItem(field)\"\n            >\n              {{ field.removeLabel || 'Remove' }}\n            </button>\n          </div>\n          <button\n            type=\"button\"\n            [attr.aria-label]=\"\n              (field.addLabel || 'Add') + ' ' + (field.label || field.name)\n            \"\n            (click)=\"onGroupItemAdd(field)\"\n            [disabled]=\"!canAddItem(field)\"\n          >\n            {{ field.addLabel || 'Add' }}\n          </button>\n        </div>\n      </ng-container>\n    </div>\n  `,\n})\nexport class MultiFieldInput implements OnInit, OnChanges {\n  @Input() fieldDescriptions: FieldDescription[] = [];\n  @Input() properties?: Properties;\n  @Output() onChange = new EventEmitter<Properties>();\n  @Output() validityChange = new EventEmitter<ValidationResult>();\n  @Input() layout: LayoutConfig = 'column';\n  // Top-level form data, threaded down through repeatable groups so a nested\n  // field's appearCondition/computeValue can read the root form. Omitted at\n  // the top level, where the form's own data is the root.\n  @Input() rootData?: Properties;\n\n  data: Properties = {};\n  visibleFields: FieldDescription[] = [];\n  private isMobile = false;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  @HostListener('window:resize')\n  onWindowResize(): void {\n    const wasMobile = this.isMobile;\n    this.updateIsMobile();\n    if (wasMobile !== this.isMobile) {\n      this.cdr.markForCheck();\n    }\n  }\n\n  get resolvedLayout(): BaseLayoutConfig {\n    if (typeof this.layout === 'object' && this.layout.type === 'responsive') {\n      return this.isMobile ? this.layout.mobile : this.layout.desktop;\n    }\n    return this.layout as BaseLayoutConfig;\n  }\n\n  get resolvedLayoutType(): string {\n    const resolved = this.resolvedLayout;\n    return typeof resolved === 'string' ? resolved : resolved.type;\n  }\n\n  get gap(): number {\n    const resolved = this.resolvedLayout;\n    if (typeof resolved === 'object' && resolved.gap !== undefined) {\n      return resolved.gap;\n    }\n    return 12;\n  }\n\n  get columns(): number {\n    const resolved = this.resolvedLayout;\n    if (typeof resolved === 'object' && resolved.type === 'grid') {\n      return resolved.columns ?? 2;\n    }\n    return 2;\n  }\n\n  trackByFn(index: number, field: FieldDescription): string | number {\n    return field.name || index;\n  }\n\n  trackByIndex(index: number): number {\n    return index;\n  }\n\n  private groupTrackByCache = new WeakMap<\n    FieldDescription,\n    (index: number, item: Properties) => unknown\n  >();\n\n  // Returns a stable trackBy per group field: item[keyField] when configured,\n  // else the index. Cached by field reference so the template hands Angular the\n  // same function each change-detection pass.\n  groupTrackBy(\n    field: FieldDescription\n  ): (index: number, item: Properties) => unknown {\n    let fn = this.groupTrackByCache.get(field);\n    if (!fn) {\n      fn = (index: number, item: Properties) =>\n        field.keyField ? item[field.keyField] ?? index : index;\n      this.groupTrackByCache.set(field, fn);\n    }\n    return fn;\n  }\n\n  ngOnInit() {\n    this.updateIsMobile();\n    this.init();\n  }\n\n  ngOnChanges(_changes: SimpleChanges) {\n    this.init();\n  }\n\n  private updateIsMobile(): void {\n    const breakpoint =\n      typeof this.layout === 'object' && this.layout.type === 'responsive'\n        ? this.layout.breakpoint ?? DEFAULT_BREAKPOINT\n        : DEFAULT_BREAKPOINT;\n    if (\n      typeof window !== 'undefined' &&\n      typeof window.matchMedia === 'function'\n    ) {\n      this.isMobile = window.matchMedia(\n        `(max-width: ${breakpoint - 1}px)`\n      ).matches;\n    } else {\n      this.isMobile =\n        typeof window !== 'undefined' && window.innerWidth < breakpoint;\n    }\n  }\n\n  private init() {\n    if (this.properties) {\n      this.data = applyComputedValues(\n        this.fieldDescriptions,\n        { ...this.properties },\n        this.rootData\n      );\n    }\n    this.updateVisibleFields();\n    this.validityChange.emit(\n      validateFields(this.fieldDescriptions, this.data, this.rootData)\n    );\n  }\n\n  private updateVisibleFields() {\n    const root = this.rootData ?? this.data;\n    this.visibleFields = this.fieldDescriptions.filter(\n      (f) => !f.appearCondition || f.appearCondition(this.data, root)\n    );\n  }\n\n  onFieldChange(event: { value: unknown; key: string }): void {\n    this.commitData({ ...this.data, [event.key]: event.value });\n  }\n\n  getItems(field: FieldDescription): Properties[] {\n    const value = this.data[field.name];\n    return Array.isArray(value) ? (value as Properties[]) : [];\n  }\n\n  getResolvedOptions(field: FieldDescription): Properties[] | undefined {\n    return resolveOptions(field, this.data, this.rootData);\n  }\n\n  getDisabled(field: FieldDescription): boolean {\n    return resolveDisabled(field, this.data, this.rootData);\n  }\n\n  getReadOnly(field: FieldDescription): boolean {\n    return resolveReadOnly(field, this.data, this.rootData);\n  }\n\n  getError(field: FieldDescription): string[] | undefined {\n    if (this.getDisabled(field)) {\n      return undefined;\n    }\n    const errors = validateField(\n      field,\n      this.data[field.name],\n      this.data,\n      this.rootData\n    );\n    return errors.length > 0 ? errors : undefined;\n  }\n\n  canAddItem(field: FieldDescription): boolean {\n    return canAddGroupItem(field, this.getItems(field));\n  }\n\n  canRemoveItem(field: FieldDescription): boolean {\n    return canRemoveGroupItem(field, this.getItems(field));\n  }\n\n  onGroupItemAdd(field: FieldDescription): void {\n    if (!this.canAddItem(field)) {\n      return;\n    }\n    const items = this.getItems(field);\n    this.commitData({\n      ...this.data,\n      [field.name]: [...items, createGroupItem(field)],\n    });\n  }\n\n  onGroupItemRemove(field: FieldDescription, index: number): void {\n    if (!this.canRemoveItem(field)) {\n      return;\n    }\n    const items = this.getItems(field).filter((_, i) => i !== index);\n    this.commitData({ ...this.data, [field.name]: items });\n  }\n\n  onGroupItemChange(\n    field: FieldDescription,\n    index: number,\n    next: Properties\n  ): void {\n    const items = this.getItems(field).slice();\n    items[index] = next;\n    this.commitData({ ...this.data, [field.name]: items });\n  }\n\n  private commitData(nextData: Properties): void {\n    this.data = applyComputedValues(\n      this.fieldDescriptions,\n      nextData,\n      this.rootData\n    );\n    this.updateVisibleFields();\n    this.onChange.emit(this.data);\n    this.validityChange.emit(\n      validateFields(this.fieldDescriptions, this.data, this.rootData)\n    );\n    this.cdr.markForCheck();\n  }\n}\n"]}

package/dist/esm2022/fieldRegistryToken.mjs

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+import { fieldRegistry } from '@dynamic-field-kit/core';
+// Injecting this token yields the process-wide singleton by default, so code
+// that never provides it keeps working. Provide it on a component/route to give
+// that subtree an isolated set of renderers:
+//
+//   providers: [{ provide: FIELD_REGISTRY, useValue: myScopedRegistry }]
+export const FIELD_REGISTRY = new InjectionToken('dfk.FieldRegistry', {
+    providedIn: 'root',
+    factory: () => fieldRegistry,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGRSZWdpc3RyeVRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpZWxkUmVnaXN0cnlUb2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9DLE9BQU8sRUFBaUIsYUFBYSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFdkUsNkVBQTZFO0FBQzdFLGdGQUFnRjtBQUNoRiw2Q0FBNkM7QUFDN0MsRUFBRTtBQUNGLHlFQUF5RTtBQUN6RSxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQzlDLG1CQUFtQixFQUNuQjtJQUNFLFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxhQUFhO0NBQzdCLENBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGaWVsZFJlZ2lzdHJ5LCBmaWVsZFJlZ2lzdHJ5IH0gZnJvbSAnQGR5bmFtaWMtZmllbGQta2l0L2NvcmUnO1xuXG4vLyBJbmplY3RpbmcgdGhpcyB0b2tlbiB5aWVsZHMgdGhlIHByb2Nlc3Mtd2lkZSBzaW5nbGV0b24gYnkgZGVmYXVsdCwgc28gY29kZVxuLy8gdGhhdCBuZXZlciBwcm92aWRlcyBpdCBrZWVwcyB3b3JraW5nLiBQcm92aWRlIGl0IG9uIGEgY29tcG9uZW50L3JvdXRlIHRvIGdpdmVcbi8vIHRoYXQgc3VidHJlZSBhbiBpc29sYXRlZCBzZXQgb2YgcmVuZGVyZXJzOlxuLy9cbi8vICAgcHJvdmlkZXJzOiBbeyBwcm92aWRlOiBGSUVMRF9SRUdJU1RSWSwgdXNlVmFsdWU6IG15U2NvcGVkUmVnaXN0cnkgfV1cbmV4cG9ydCBjb25zdCBGSUVMRF9SRUdJU1RSWSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGaWVsZFJlZ2lzdHJ5PihcbiAgJ2Rmay5GaWVsZFJlZ2lzdHJ5JyxcbiAge1xuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBmaWVsZFJlZ2lzdHJ5LFxuICB9XG4pO1xuIl19

package/dist/esm2022/layout/defaultLayouts.mjs

@@ -1,13 +1,22 @@
 import { CommonModule } from '@angular/common';
-import { Component } from '@angular/core';
+import { Component, Input } from '@angular/core';
+import { layoutRegistry } from './layoutRegistry';
 import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
 export class ColumnLayout {
+    config;
+    template;
+    get gap() {
+        return this.config?.gap ?? 12;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ColumnLayout, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: ColumnLayout, isStandalone: true, selector: "dfk-column-layout", ngImport: i0, template: `<div
-    style="display:flex;flex-direction:column;gap:var(--dfk-gap,12px)"
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: ColumnLayout, isStandalone: true, selector: "dfk-column-layout", inputs: { config: "config", template: "template" }, ngImport: i0, template: `<div
+    [style.display]="'flex'"
+    [style.flexDirection]="'column'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
-  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+    <ng-container *ngTemplateOutlet="template"></ng-container>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ColumnLayout, decorators: [{
             type: Component,
@@ -16,19 +25,32 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                     standalone: true,
                     imports: [CommonModule],
                     template: `<div
-    style="display:flex;flex-direction:column;gap:var(--dfk-gap,12px)"
+    [style.display]="'flex'"
+    [style.flexDirection]="'column'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
+    <ng-container *ngTemplateOutlet="template"></ng-container>
   </div>`,
                 }]
-        }] });
+        }], propDecorators: { config: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }] } });
 export class RowLayout {
+    config;
+    template;
+    get gap() {
+        return this.config?.gap ?? 12;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: RowLayout, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: RowLayout, isStandalone: true, selector: "dfk-row-layout", ngImport: i0, template: `<div
-    style="display:flex;flex-direction:row;gap:var(--dfk-gap,12px)"
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: RowLayout, isStandalone: true, selector: "dfk-row-layout", inputs: { config: "config", template: "template" }, ngImport: i0, template: `<div
+    [style.display]="'flex'"
+    [style.flexDirection]="'row'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
-  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+    <ng-container *ngTemplateOutlet="template"></ng-container>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: RowLayout, decorators: [{
             type: Component,
@@ -37,19 +59,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                     standalone: true,
                     imports: [CommonModule],
                     template: `<div
-    style="display:flex;flex-direction:row;gap:var(--dfk-gap,12px)"
+    [style.display]="'flex'"
+    [style.flexDirection]="'row'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
+    <ng-container *ngTemplateOutlet="template"></ng-container>
   </div>`,
                 }]
-        }] });
+        }], propDecorators: { config: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }] } });
 export class GridLayout {
+    config;
+    template;
+    get columns() {
+        return this.config?.columns ?? 2;
+    }
+    get gap() {
+        return this.config?.gap ?? 12;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: GridLayout, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: GridLayout, isStandalone: true, selector: "dfk-grid-layout", ngImport: i0, template: `<div
-    style="display:grid;grid-template-columns:repeat(var(--dfk-columns,2),1fr);gap:var(--dfk-gap,12px)"
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: GridLayout, isStandalone: true, selector: "dfk-grid-layout", inputs: { config: "config", template: "template" }, ngImport: i0, template: `<div
+    [style.display]="'grid'"
+    [style.gridTemplateColumns]="'repeat(' + columns + ', 1fr)'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
-  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+    <ng-container *ngTemplateOutlet="template"></ng-container>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: GridLayout, decorators: [{
             type: Component,
@@ -58,10 +96,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
                     standalone: true,
                     imports: [CommonModule],
                     template: `<div
-    style="display:grid;grid-template-columns:repeat(var(--dfk-columns,2),1fr);gap:var(--dfk-gap,12px)"
+    [style.display]="'grid'"
+    [style.gridTemplateColumns]="'repeat(' + columns + ', 1fr)'"
+    [style.gap]="gap + 'px'"
   >
-    <ng-content></ng-content>
+    <ng-container *ngTemplateOutlet="template"></ng-container>
   </div>`,
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], propDecorators: { config: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }] } });
+layoutRegistry.register('column', ColumnLayout);
+layoutRegistry.register('row', RowLayout);
+layoutRegistry.register('grid', GridLayout);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/layout/index.mjs

@@ -1,2 +1,3 @@
 export * from './defaultLayouts';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGF5b3V0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RlZmF1bHRMYXlvdXRzJztcbiJdfQ==
+export { layoutRegistry, LayoutRegistry } from './layoutRegistry';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGF5b3V0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsT0FBTyxFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdExheW91dHMnO1xuZXhwb3J0IHsgbGF5b3V0UmVnaXN0cnksIExheW91dFJlZ2lzdHJ5IH0gZnJvbSAnLi9sYXlvdXRSZWdpc3RyeSc7XG4iXX0=

package/dist/esm2022/layout/layoutRegistry.mjs

@@ -0,0 +1,14 @@
+export class LayoutRegistry {
+    layouts = new Map();
+    register(type, component) {
+        if (this.layouts.has(type)) {
+            console.warn(`[dynamic-field-kit] Layout "${type}" already exists`);
+        }
+        this.layouts.set(type, component);
+    }
+    get(type) {
+        return this.layouts.get(type);
+    }
+}
+export const layoutRegistry = new LayoutRegistry();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF5b3V0UmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGF5b3V0L2xheW91dFJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE1BQU0sT0FBTyxjQUFjO0lBQ2pCLE9BQU8sR0FBRyxJQUFJLEdBQUcsRUFBa0MsQ0FBQztJQUU1RCxRQUFRLENBQUMsSUFBWSxFQUFFLFNBQWlDO1FBQ3RELElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztZQUMzQixPQUFPLENBQUMsSUFBSSxDQUFDLCtCQUErQixJQUFJLGtCQUFrQixDQUFDLENBQUM7UUFDdEUsQ0FBQztRQUNELElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQsR0FBRyxDQUFDLElBQVk7UUFDZCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hDLENBQUM7Q0FDRjtBQUVELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgdHlwZSBMYXlvdXRSZW5kZXJlcjxDID0gdW5rbm93bj4gPSAocHJvcHM6IHtcbiAgY2hpbGRyZW46IHVua25vd25bXTtcbiAgY29uZmlnPzogQztcbn0pID0+IHVua25vd247XG5cbmV4cG9ydCB0eXBlIEFuZ3VsYXJMYXlvdXRDb21wb25lbnQgPSBUeXBlPHVua25vd24+O1xuXG5leHBvcnQgY2xhc3MgTGF5b3V0UmVnaXN0cnkge1xuICBwcml2YXRlIGxheW91dHMgPSBuZXcgTWFwPHN0cmluZywgQW5ndWxhckxheW91dENvbXBvbmVudD4oKTtcblxuICByZWdpc3Rlcih0eXBlOiBzdHJpbmcsIGNvbXBvbmVudDogQW5ndWxhckxheW91dENvbXBvbmVudCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmxheW91dHMuaGFzKHR5cGUpKSB7XG4gICAgICBjb25zb2xlLndhcm4oYFtkeW5hbWljLWZpZWxkLWtpdF0gTGF5b3V0IFwiJHt0eXBlfVwiIGFscmVhZHkgZXhpc3RzYCk7XG4gICAgfVxuICAgIHRoaXMubGF5b3V0cy5zZXQodHlwZSwgY29tcG9uZW50KTtcbiAgfVxuXG4gIGdldCh0eXBlOiBzdHJpbmcpOiBBbmd1bGFyTGF5b3V0Q29tcG9uZW50IHwgdW5kZWZpbmVkIHtcbiAgICByZXR1cm4gdGhpcy5sYXlvdXRzLmdldCh0eXBlKTtcbiAgfVxufVxuXG5leHBvcnQgY29uc3QgbGF5b3V0UmVnaXN0cnkgPSBuZXcgTGF5b3V0UmVnaXN0cnkoKTtcbiJdfQ==

package/dist/esm2022/public-api.mjs

@@ -10,5 +10,9 @@ export * from './types/layout';
 // Module
 export * from './lib/dynamic-field-kit.module';
 // Optional: expose registry for advanced use cases, but not required for basic usage
-export { fieldRegistry } from '@dynamic-field-kit/core';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdCQUFnQjtBQUVoQixhQUFhO0FBQ2IsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw4QkFBOEIsQ0FBQztBQUU3QyxTQUFTO0FBQ1QsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxnQkFBZ0IsQ0FBQztBQUUvQixTQUFTO0FBQ1QsY0FBYyxnQ0FBZ0MsQ0FBQztBQVMvQyxxRkFBcUY7QUFDckYsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gcHVibGljLWFwaS50c1xyXG5cclxuLy8gQ29tcG9uZW50c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvQmFzZUlucHV0JztcclxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL0R5bmFtaWNJbnB1dCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9GaWVsZElucHV0JztcclxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL011bHRpRmllbGRJbnB1dCc7XHJcblxyXG4vLyBMYXlvdXRcclxuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzL2xheW91dCc7XHJcblxyXG4vLyBNb2R1bGVcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZHluYW1pYy1maWVsZC1raXQubW9kdWxlJztcclxuXHJcbi8vIFJlLWV4cG9ydCB0eXBlcyBmcm9tIGNvcmUgKG9ubHkgdHlwZSwgbm90IGV4cG9ydCAqIClcclxuZXhwb3J0IHR5cGUge1xyXG4gIEZpZWxkVHlwZUtleSxcclxuICBGaWVsZERlc2NyaXB0aW9uLFxyXG4gIEZpZWxkUmVuZGVyZXJQcm9wcyxcclxufSBmcm9tICdAZHluYW1pYy1maWVsZC1raXQvY29yZSc7XHJcblxyXG4vLyBPcHRpb25hbDogZXhwb3NlIHJlZ2lzdHJ5IGZvciBhZHZhbmNlZCB1c2UgY2FzZXMsIGJ1dCBub3QgcmVxdWlyZWQgZm9yIGJhc2ljIHVzYWdlXHJcbmV4cG9ydCB7IGZpZWxkUmVnaXN0cnkgfSBmcm9tICdAZHluYW1pYy1maWVsZC1raXQvY29yZSc7XHJcbiJdfQ==
+export { fieldRegistry, FieldRegistry } from '@dynamic-field-kit/core';
+export { validateField, validateFieldAsync, validateFields, validateFieldsAsync, resolveDisabled, resolveReadOnly, resolveOptions, validators, } from '@dynamic-field-kit/core';
+// Scoped registry: provide FIELD_REGISTRY on a component/route to give that
+// subtree an isolated set of renderers.
+export { FIELD_REGISTRY } from './fieldRegistryToken';
+//# sourceMappingURL=data:application/json;base64,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