@ng-forge/dynamic-forms 0.10.0-next.1 → 0.10.0-next.3

package/fesm2022/{ng-forge-dynamic-forms-array-field.component-GiaVHO9N.mjs → ng-forge-dynamic-forms-array-field.component-D6GEsH72.mjs}

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
 import { signal, computed, runInInjectionContext, Injector, linkedSignal, inject, DestroyRef, EnvironmentInjector, input, ChangeDetectionStrategy, Component } from '@angular/core';
-import { O as RootFormRegistryService, ax as isEqual, aL as mapFieldToInputs, v as FIELD_SIGNAL_CONTEXT, e as ARRAY_CONTEXT, G as GROUP_CONTEXT, a5 as createHiddenSignal, a6 as createRenderReadySignal, s as DynamicFormLogger, ao as injectFieldRegistry, ap as injectFieldSignalContext, E as EventBus, g as ArrayItemRegistryService, ak as getNormalizedArrayMetadata, aj as getFieldValueHandling, ai as getFieldDefaultValue, aA as isGroupField, o as DfFieldOutlet } from './ng-forge-dynamic-forms-ng-forge-dynamic-forms--PuL0AKc.mjs';
+import { O as RootFormRegistryService, ax as isEqual, aL as mapFieldToInputs, v as FIELD_SIGNAL_CONTEXT, e as ARRAY_CONTEXT, G as GROUP_CONTEXT, a5 as createHiddenSignal, a6 as createRenderReadySignal, s as DynamicFormLogger, ao as injectFieldRegistry, ap as injectFieldSignalContext, E as EventBus, g as ArrayItemRegistryService, ak as getNormalizedArrayMetadata, aj as getFieldValueHandling, ai as getFieldDefaultValue, aA as isGroupField, o as DfFieldOutlet } from './ng-forge-dynamic-forms-ng-forge-dynamic-forms-CPkVjU_N.mjs';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { of, from, map, catchError, forkJoin, filter, firstValueFrom, tap } from 'rxjs';
 import { explicitEffect } from 'ngxtension/explicit-effect';
-import { e as emitComponentInitialized } from './ng-forge-dynamic-forms-emit-initialization-3PyXVwsn.mjs';
+import { e as emitComponentInitialized } from './ng-forge-dynamic-forms-emit-initialization-CB86IMsQ.mjs';
 
 class ArrayFieldStateMachine {
     _state = signal('idle', ...(ngDevMode ? [{ debugName: "_state" }] : /* istanbul ignore next */ []));
@@ -13,8 +13,7 @@ class ArrayFieldStateMachine {
     _hasEverEmitted = false;
     state = this._state.asReadonly();
     runId = this._runId.asReadonly();
-    /** True after the first `componentInitialized` pulse has fired for this component. */
-    get hasEverEmitted() {
+        get hasEverEmitted() {
         return this._hasEverEmitted;
     }
     dispatch(op) {
@@ -27,9 +26,7 @@ class ArrayFieldStateMachine {
                 this._state.set('pending');
                 break;
             case 'append':
-                // append doesn't reset state — mirrors today's behavior where
-                // appendItems leaves the init-cycle tracking alone.
-                break;
+                                                break;
         }
         return {
             id: nextId,
@@ -41,12 +38,7 @@ class ArrayFieldStateMachine {
             },
         };
     }
-    /**
-     * Edge-trigger for the emit-effect. Returns true exactly once per `settled` run
-     * when `allReady` is true. Side-effect: records the run as emitted and transitions
-     * the state back to `idle`. Subsequent calls without a fresh dispatch return false.
-     */
-    shouldEmit(allReady) {
+        shouldEmit(allReady) {
         if (this._state() !== 'settled' || !allReady)
             return false;
         if (this.lastEmittedRunId === this._runId())
@@ -58,29 +50,10 @@ class ArrayFieldStateMachine {
     }
 }
 
-/**
- * Safely extracts an array value from a model object.
- * Returns empty array if the key doesn't exist or value isn't an array.
- */
 function getArrayValue(value, key) {
     const arrayValue = value?.[key];
     return Array.isArray(arrayValue) ? arrayValue : [];
 }
-/**
- * Determines the optimal differential update operation based on current and new state.
- *
- * Operations:
- * - Clear all (empty array)
- * - Initial render (no existing items)
- * - Append only (items added at end)
- * - Recreate (items removed - we can't know which items, so recreate all)
- * - None (same length - items update via linkedSignal)
- *
- * Note: We always use 'recreate' for removals because we can't determine which
- * specific items were removed. Operations like shift, removeAtIndex remove from
- * the middle, not just the end. Each array item has its own local form that
- * doesn't reactively track parent changes, so we must recreate to get correct values.
- */
 function determineDifferentialOperation(currentItems, newLength) {
     const currentLength = currentItems.length;
     if (newLength === 0) {
@@ -89,53 +62,25 @@ function determineDifferentialOperation(currentItems, newLength) {
     if (currentLength === 0) {
         return { type: 'initial', fieldTreesLength: newLength };
     }
-    // For all length changes, we optimize by assuming existing items stay in place.
-    // Items handle their own value updates via linkedSignal - no need to compare snapshots.
-    // Snapshot comparison was causing false "recreate" when existing items had been edited.
-    if (newLength > currentLength) {
-        // Items added - append new ones, existing items stay
-        return { type: 'append', startIndex: currentLength, endIndex: newLength };
+                if (newLength > currentLength) {
+                return { type: 'append', startIndex: currentLength, endIndex: newLength };
     }
     if (newLength < currentLength) {
-        // Items removed - must recreate because we don't know which items were removed.
-        // shift() removes from index 0, removeAtIndex() removes from any position.
-        // Each item's local form is initialized with its value at creation time and
-        // doesn't reactively track parent array changes.
-        return { type: 'recreate' };
+                                        return { type: 'recreate' };
     }
-    // Same length - no structural change, items update via linkedSignal
-    return { type: 'none' };
+        return { type: 'none' };
 }
 
-/**
- * Creates an injector and inputs for an array item.
- *
- * Uses direct root form binding - components bind directly to the root form's
- * FieldTree for array items (rootForm['arrayKey'][index]). This architecture:
- *
- * - Eliminates the need for local forms and bidirectional sync
- * - Allows Zod/StandardSchema validation errors to flow naturally to components
- * - Reduces complexity by having a single source of truth (the root form)
- *
- * The FieldSignalContext.form property uses a getter that evaluates a computed
- * signal, making form access reactive to index changes (when items reorder,
- * the component points to the correct array position).
- */
 function createArrayItemInjectorAndInputs(options) {
     const { template, indexSignal, parentFieldSignalContext, parentInjector, registry, arrayField, primitiveFieldKey } = options;
-    // Get root form registry - it's guaranteed to be available since root form
-    // is registered before resolvedFields computes (dependency chain ensures this)
-    const rootFormRegistry = parentInjector.get(RootFormRegistryService);
-    // Create a computed that derives the array item's FieldTree from root form.
-    // Uses isEqual to prevent unnecessary re-computation when index changes but value is same.
-    const itemFormAccessor = computed(() => {
+            const rootFormRegistry = parentInjector.get(RootFormRegistryService);
+            const itemFormAccessor = computed(() => {
         const rootForm = rootFormRegistry.rootForm();
         if (!rootForm) {
             return undefined;
         }
         const index = indexSignal();
-        // Navigate: rootForm['arrayKey'][index]
-        const arrayFieldTree = rootForm[arrayField.key];
+                const arrayFieldTree = rootForm[arrayField.key];
         if (!arrayFieldTree) {
             return undefined;
         }
@@ -149,30 +94,14 @@ function createArrayItemInjectorAndInputs(options) {
         arrayField,
         primitiveFieldKey,
     });
-    // mapFieldToInputs automatically reads ARRAY_CONTEXT from the injector
-    // and applies the index suffix to keys for unique DOM IDs
-    const inputs = runInInjectionContext(injector, () => {
+            const inputs = runInInjectionContext(injector, () => {
         return mapFieldToInputs(template, registry);
     });
     return { injector, inputs };
 }
-/**
- * Creates a scoped injector for an array item.
- * Provides both FIELD_SIGNAL_CONTEXT (for form access) and ARRAY_CONTEXT (for position awareness).
- *
- * The FIELD_SIGNAL_CONTEXT.form uses a getter that evaluates itemFormAccessor() on access.
- * This makes form access reactive - when mappers access context.form['fieldKey'], the getter runs,
- * evaluating the computed which tracks indexSignal as a dependency. This ensures components
- * automatically update when array items reorder.
- *
- * Uses `useFactory` with `deps: [Injector]` to provide FIELD_SIGNAL_CONTEXT. Angular resolves
- * the `Injector` dep as the child injector being created, eliminating any temporal gap.
- */
 function createItemInjector(options) {
     const { itemFormAccessor, indexSignal, parentFieldSignalContext, parentInjector, arrayField, primitiveFieldKey } = options;
-    // Use getter for formValue to ensure it's always current, not a stale snapshot.
-    // Components accessing arrayContext.formValue will get the current value.
-    const arrayContext = {
+            const arrayContext = {
         arrayKey: arrayField.key,
         index: indexSignal,
         get formValue() {
@@ -180,40 +109,24 @@ function createItemInjector(options) {
         },
         field: arrayField,
     };
-    // Cache for the primitive wrapper object — avoids creating a new { [primitiveFieldKey]: raw }
-    // on every form getter access, which would defeat reference-equality checks downstream.
-    let cachedPrimitiveRaw;
+            let cachedPrimitiveRaw;
     let cachedPrimitiveWrapped;
     return Injector.create({
         parent: parentInjector,
         providers: [
             {
                 provide: FIELD_SIGNAL_CONTEXT,
-                // Angular resolves `Injector` in deps as the child injector being created,
-                // so no temporal gap exists — the injector reference is immediately available.
-                useFactory: (injector) => ({
+                                                useFactory: (injector) => ({
                     injector,
                     value: parentFieldSignalContext.value,
-                    // Array items don't propagate parent default values because each item's defaults
-                    // are determined by its template fields at creation time (via getFieldDefaultValue).
-                    // The parent's defaultValues contain top-level form defaults, not per-item defaults.
-                    defaultValues: () => ({}),
+                                                                                defaultValues: () => ({}),
                     get form() {
                         const raw = itemFormAccessor();
                         if (!raw) {
-                            // During initialization or transitions, the FieldTree may not be available yet.
-                            // This occurs in the window between item creation and Angular's form tree construction.
-                            // Return an empty object so that downstream getFieldTree(key) calls return undefined
-                            // rather than causing a runtime error on a truly undefined value.
-                            return {};
+                                                                                                                                            return {};
                         }
-                        // For primitive array items, the FieldTree is a FormControl (the item IS the control).
-                        // Wrap it in an object so getFieldTree(primitiveFieldKey) returns the FormControl itself.
-                        // Without this, getFieldTree('value') would access FormControl['value'] (the WritableSignal),
-                        // not a child FieldTree, causing NG0950 errors.
-                        if (primitiveFieldKey) {
-                            // Cache the wrapper to preserve reference identity when raw hasn't changed
-                            if (raw !== cachedPrimitiveRaw) {
+                                                                                                                        if (primitiveFieldKey) {
+                                                        if (raw !== cachedPrimitiveRaw) {
                                 cachedPrimitiveRaw = raw;
                                 cachedPrimitiveWrapped = { [primitiveFieldKey]: raw };
                             }
@@ -225,51 +138,27 @@ function createItemInjector(options) {
                 deps: [Injector],
             },
             { provide: ARRAY_CONTEXT, useValue: arrayContext },
-            // Reset GROUP_CONTEXT at the array boundary: inner groups inside each
-            // item start their path fresh, matching how value-derivation and
-            // property-derivation collectors key entries
-            // (`{arrayKey}.$.{innerGroupPath}.{fieldKey}`). Without this, an outer
-            // group around the array would leak into descendants' DOM IDs and
-            // override-store keys, drifting from the collector.
-            { provide: GROUP_CONTEXT, useValue: EMPTY_GROUP_CONTEXT },
+                                                                                    { provide: GROUP_CONTEXT, useValue: EMPTY_GROUP_CONTEXT },
         ],
     });
 }
-/**
- * Sentinel `GroupContext` provided at array item boundaries. Static `signal('')`
- * means `applyGroupPrefix` no-ops (empty path) and any inner group composes its
- * own path from this empty base.
- */
 const EMPTY_GROUP_CONTEXT = { groupPath: signal('') };
 
-/**
- * Resolves a single array item with all its fields for declarative rendering.
- *
- * Uses linkedSignal for the index, which automatically updates when itemOrderSignal changes.
- * This enables position-aware updates without recreating components when items are reordered.
- * Supports multiple sibling templates (e.g., name + email without a wrapper).
- */
 function resolveArrayItem(options) {
     const { index, templates, arrayField, itemPositionMap, parentFieldSignalContext, parentInjector, registry, destroyRef, loadTypeComponent, generateItemId, existingItemId, primitiveFieldKey, } = options;
     if (templates.length === 0) {
         return of(undefined);
     }
-    // Generate ONE id for this array item (shared by all fields for tracking), unless
-    // the caller is rehydrating an existing item — in which case reuse its id so the
-    // form-scoped template registry continues to map cleanly.
-    const itemId = existingItemId ?? generateItemId();
-    // O(1) position lookup via Map instead of O(n) indexOf()
-    const indexSignal = linkedSignal(() => {
+                const itemId = existingItemId ?? generateItemId();
+        const indexSignal = linkedSignal(() => {
         const positionMap = itemPositionMap();
         return positionMap.get(itemId) ?? index;
     }, ...(ngDevMode ? [{ debugName: "indexSignal" }] : /* istanbul ignore next */ []));
-    // Resolve all templates in parallel
-    const fieldObservables = templates.map((template) => from(loadTypeComponent(template.type)).pipe(map((component) => {
+        const fieldObservables = templates.map((template) => from(loadTypeComponent(template.type)).pipe(map((component) => {
         if (destroyRef.destroyed) {
             return undefined;
         }
-        // Componentless fields (e.g., hidden) return undefined - nothing to render
-        if (!component) {
+                if (!component) {
             return undefined;
         }
         const { injector, inputs } = createArrayItemInjectorAndInputs({
@@ -281,8 +170,7 @@ function resolveArrayItem(options) {
             arrayField,
             primitiveFieldKey,
         });
-        // Array item templates should always have inputs (componentless fields are handled above)
-        if (!inputs) {
+                if (!inputs) {
             return undefined;
         }
         return {
@@ -304,8 +192,7 @@ function resolveArrayItem(options) {
     })));
     return forkJoin(fieldObservables).pipe(map((fields) => {
         const validFields = fields.filter((f) => f !== undefined);
-        // If no fields resolved, return undefined
-        if (validFields.length === 0) {
+                if (validFields.length === 0) {
             return undefined;
         }
         return {
@@ -315,9 +202,6 @@ function resolveArrayItem(options) {
     }));
 }
 
-/**
- * All array event type discriminants.
- */
 const ARRAY_EVENT_TYPES = [
     'append-array-item',
     'prepend-array-item',
@@ -327,10 +211,6 @@ const ARRAY_EVENT_TYPES = [
     'shift-array-item',
     'remove-at-index',
 ];
-/**
- * Converts an array event to a normalized action.
- * Uses a switch for full type safety with discriminated union narrowing.
- */
 function toArrayAction(event) {
     switch (event.type) {
         case 'append-array-item':
@@ -349,43 +229,12 @@ function toArrayAction(event) {
             return { action: 'remove', index: event.index };
     }
 }
-/**
- * Creates an observable stream of normalized array actions for a specific array key.
- *
- * @param eventBus - The event bus to subscribe to
- * @param arrayKey - Function returning the array key to filter events for
- * @returns Observable of normalized ArrayAction objects
- *
- * @example
- * ```typescript
- * observeArrayActions(this.eventBus, () => this.key())
- *   .pipe(takeUntilDestroyed())
- *   .subscribe(action => {
- *     if (action.action === 'add') {
- *       this.addItem(action.template, action.index);
- *     } else {
- *       this.removeItem(action.index);
- *     }
- *   });
- * ```
- */
 function observeArrayActions(eventBus, arrayKey) {
     return eventBus.on(ARRAY_EVENT_TYPES).pipe(filter((event) => event.arrayKey === arrayKey()), map(toArrayAction));
 }
 
-/**
- * Container component for rendering dynamic arrays of fields.
- *
- * Supports add/remove/move operations via the arrayEvent() builder API.
- * Uses differential updates to optimize rendering - only recreates items when necessary.
- * Each item gets a scoped injector with ARRAY_CONTEXT for position-aware operations.
- * Supports multiple sibling fields per array item (e.g., name + email without a wrapper).
- */
 class ArrayFieldComponent {
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Dependencies
-    // ─────────────────────────────────────────────────────────────────────────────
-    destroyRef = inject(DestroyRef);
+                destroyRef = inject(DestroyRef);
     fieldRegistry = injectFieldRegistry();
     parentFieldSignalContext = injectFieldSignalContext();
     parentInjector = inject(Injector);
@@ -393,112 +242,47 @@ class ArrayFieldComponent {
     eventBus = inject(EventBus);
     logger = inject(DynamicFormLogger);
     arrayItemRegistry = inject(ArrayItemRegistryService);
-    // Form-scoped slot keyed by the array's path. Survives this component's lifecycle so that
-    // `@if`-gated arrays can be destroyed and recreated without losing dynamically-added items.
-    // NOTE: keyed by `field().key` for now — nested arrays with the same key in different scopes
-    // would currently collide. Today's per-component-provider model has the same constraint
-    // (no nested-array hide/show tests exist). Path-aware keying is a follow-up.
-    // `field()` is `input.required`, so the slot reference is resolved lazily.
-    slot = computed(() => this.arrayItemRegistry.slotFor(this.field().key), ...(ngDevMode ? [{ debugName: "slot" }] : /* istanbul ignore next */ []));
-    /** Bound id-generator reference threaded to `resolveArrayItem` so callsites stay terse. */
-    generateItemId = () => this.slot().nextId();
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Inputs
-    // ─────────────────────────────────────────────────────────────────────────────
-    field = input.required(...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
+                            slot = computed(() => this.arrayItemRegistry.slotFor(this.field().key), ...(ngDevMode ? [{ debugName: "slot" }] : /* istanbul ignore next */ []));
+        generateItemId = () => this.slot().nextId();
+                field = input.required(...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
     key = input.required(...(ngDevMode ? [{ debugName: "key" }] : /* istanbul ignore next */ []));
     className = input(...(ngDevMode ? [undefined, { debugName: "className" }] : /* istanbul ignore next */ []));
     hidden = input(false, ...(ngDevMode ? [{ debugName: "hidden" }] : /* istanbul ignore next */ []));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Computed Signals
-    // ─────────────────────────────────────────────────────────────────────────────
-    hostClasses = computed(() => {
+                hostClasses = computed(() => {
         const base = 'df-field df-array';
         const custom = this.className();
         return custom ? `${base} ${custom}` : base;
     }, ...(ngDevMode ? [{ debugName: "hostClasses" }] : /* istanbul ignore next */ []));
     rawFieldRegistry = computed(() => this.fieldRegistry.raw, ...(ngDevMode ? [{ debugName: "rawFieldRegistry" }] : /* istanbul ignore next */ []));
-    /**
-     * Gets the auto-remove button FieldDef from normalization metadata.
-     * Set by simplified array normalization for primitive arrays with remove buttons.
-     * The button is rendered alongside each item without wrapping in a row,
-     * preserving flat primitive form values.
-     */
-    autoRemoveButton = computed(() => {
+        autoRemoveButton = computed(() => {
         const metadata = getNormalizedArrayMetadata(this.field());
         return metadata?.autoRemoveButton;
     }, ...(ngDevMode ? [{ debugName: "autoRemoveButton" }] : /* istanbul ignore next */ []));
-    /**
-     * For primitive array items, the key of the value field template (e.g., 'value').
-     * Used to wrap the FormControl in the item context so getFieldTree(key) works.
-     * Returns undefined for object arrays (FormGroup items have natural child navigation).
-     *
-     * Detection order:
-     * 1. Normalization metadata (for simplified arrays — always available at normalization time)
-     * 2. Existing item definitions (non-empty full-API arrays)
-     * 3. Dynamically discovered key from handleAddFromEvent (empty full-API arrays)
-     *
-     * Uses linkedSignal: recomputes when field() changes, supports manual set()
-     * for the dynamic discovery case.
-     */
-    primitiveFieldKey = linkedSignal(() => {
-        // Priority 1: Normalization metadata (simplified arrays always have this)
-        const metadata = getNormalizedArrayMetadata(this.field());
+        primitiveFieldKey = linkedSignal(() => {
+                const metadata = getNormalizedArrayMetadata(this.field());
         if (metadata?.primitiveFieldKey) {
             return metadata.primitiveFieldKey;
         }
-        // Priority 2: Existing item definitions (full-API arrays with initial items)
-        const definitions = this.field().fields || [];
+                const definitions = this.field().fields || [];
         if (definitions.length > 0 && !Array.isArray(definitions[0])) {
             return definitions[0].key;
         }
         return undefined;
     }, ...(ngDevMode ? [{ debugName: "primitiveFieldKey" }] : /* istanbul ignore next */ []));
-    /**
-     * Normalized item templates WITHOUT auto-remove button appended.
-     * Each element is normalized to an array: single FieldDef → [FieldDef], array stays as-is.
-     *
-     * Used by moveItem() to stash raw templates into the templateRegistry, preserving
-     * the invariant that registry entries are pre-synthesis (withAutoRemove() adds the
-     * button during resolution).
-     */
-    rawItemTemplates = computed(() => {
+        rawItemTemplates = computed(() => {
         const arrayField = this.field();
         const definitions = arrayField.fields || [];
         return definitions.map((def) => {
             return (Array.isArray(def) ? def : [def]);
         });
     }, ...(ngDevMode ? [{ debugName: "rawItemTemplates" }] : /* istanbul ignore next */ []));
-    /**
-     * Resolves the effective fallback template for this array — used when the form
-     * value contains an item with no registered template (i.e., items that were
-     * neither added via event handlers nor covered by a positional entry in `fields`).
-     *
-     * Populated from `SimplifiedArrayField.template` via normalization metadata, so every
-     * simplified array gets an automatic default. Returns undefined for full-API arrays;
-     * `createResolveItemObservable` then falls back to warn-and-drop.
-     *
-     * Homogeneous arrays only — all fallback items receive the same template.
-     */
-    fallbackTemplate = computed(() => {
+        fallbackTemplate = computed(() => {
         const raw = getNormalizedArrayMetadata(this.field())?.template;
         if (!raw)
             return undefined;
         return (Array.isArray(raw) ? [...raw] : [raw]);
     }, ...(ngDevMode ? [{ debugName: "fallbackTemplate" }] : /* istanbul ignore next */ []));
-    /**
-     * Gets the item templates (field definitions) for the array.
-     * Each element can be either:
-     * - A single FieldDef (primitive item) - normalized to [FieldDef]
-     * - An array of FieldDefs (object item) - used as-is
-     *
-     * When auto-remove is configured, the remove button is appended to each item's
-     * template list for rendering. This is purely visual — the form schema uses the
-     * original primitive item definition (single FieldDef → FormControl → flat value).
-     *
-     * Returns normalized templates where all items are arrays for consistent handling.
-     */
-    itemTemplates = computed(() => {
+        itemTemplates = computed(() => {
         const raw = this.rawItemTemplates();
         const removeButton = this.autoRemoveButton();
         if (!removeButton)
@@ -516,38 +300,22 @@ class ArrayFieldComponent {
         const arrayFieldTree = parentForm[arrayKey];
         if (!arrayFieldTree)
             return arrayValue.map(() => null);
-        // Access array items via bracket notation - Angular Signal Forms arrays support this
-        const items = [];
+                const items = [];
         for (let i = 0; i < arrayValue.length; i++) {
-            // Access item FieldTree directly via numeric indexing (ArrayFieldTree supports this)
-            const itemFieldTree = arrayFieldTree[i];
+                        const itemFieldTree = arrayFieldTree[i];
             items.push(itemFieldTree ?? null);
         }
         return items;
     }, ...(ngDevMode ? [{ debugName: "arrayFieldTrees" }] : /* istanbul ignore next */ []));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // State Signals
-    // ─────────────────────────────────────────────────────────────────────────────
-    resolvedItemsSignal = signal([], ...(ngDevMode ? [{ debugName: "resolvedItemsSignal" }] : /* istanbul ignore next */ []));
-    // Explicit state machine for async resolution + componentInitialized emission.
-    // Replaces the prior updateVersion + pendingInitializationCycle + settledInitializationCycle trio.
-    fsm = new ArrayFieldStateMachine();
-    /**
-     * Map of item IDs to their current positions. O(1) lookup vs O(n) indexOf().
-     * Used by child linkedSignals to reactively track their position in the array.
-     */
-    itemPositionMap = computed(() => {
+                resolvedItemsSignal = signal([], ...(ngDevMode ? [{ debugName: "resolvedItemsSignal" }] : /* istanbul ignore next */ []));
+            fsm = new ArrayFieldStateMachine();
+        itemPositionMap = computed(() => {
         const items = this.resolvedItemsSignal();
         return new Map(items.map((item, idx) => [item.id, idx]));
     }, ...(ngDevMode ? [{ debugName: "itemPositionMap" }] : /* istanbul ignore next */ []));
-    /** Read-only view of resolved items for template consumption. */
-    resolvedItems = computed(() => this.resolvedItemsSignal(), ...(ngDevMode ? [{ debugName: "resolvedItems" }] : /* istanbul ignore next */ []));
+        resolvedItems = computed(() => this.resolvedItemsSignal(), ...(ngDevMode ? [{ debugName: "resolvedItems" }] : /* istanbul ignore next */ []));
     allResolvedFieldsRenderReady = computed(() => this.resolvedItems().every((item) => item.fields.every((field) => field.renderReady())), ...(ngDevMode ? [{ debugName: "allResolvedFieldsRenderReady" }] : /* istanbul ignore next */ []));
-    /**
-     * Whether the array has reached its configured maxLength.
-     * Exposed as a public signal so add-button components can bind [disabled]="atMaxLength()".
-     */
-    atMaxLength = computed(() => {
+        atMaxLength = computed(() => {
         const maxLength = this.field().maxLength;
         if (maxLength === undefined)
             return false;
@@ -555,30 +323,13 @@ class ArrayFieldComponent {
         const currentArray = getArrayValue(this.parentFieldSignalContext.value(), arrayKey);
         return currentArray.length >= maxLength;
     }, ...(ngDevMode ? [{ debugName: "atMaxLength" }] : /* istanbul ignore next */ []));
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Auto-remove Cache
-    // ─────────────────────────────────────────────────────────────────────────────
-    /**
-     * Caches the result of appending the auto-remove button to template arrays.
-     * Keyed by template array reference — cache hits occur during recreate/resolution
-     * operations where stored template references are reused. Add operations via
-     * handleAddFromEvent always create a fresh `[...template]` copy (line ~277),
-     * so each add is a cache miss by design (the spread is needed for mutability).
-     */
-    autoRemoveCache = new WeakMap();
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Constructor
-    // ─────────────────────────────────────────────────────────────────────────────
-    constructor() {
+                    autoRemoveCache = new WeakMap();
+                constructor() {
         this.setupEffects();
         this.setupEventHandlers();
     }
-    // ─────────────────────────────────────────────────────────────────────────────
-    // Private Methods
-    // ─────────────────────────────────────────────────────────────────────────────
-    setupEffects() {
-        // Sync field components when array data changes
-        explicitEffect([this.arrayFieldTrees], ([fieldTrees]) => {
+                setupEffects() {
+                explicitEffect([this.arrayFieldTrees], ([fieldTrees]) => {
             this.performDifferentialUpdate(fieldTrees);
         });
         explicitEffect([this.fsm.state, this.allResolvedFieldsRenderReady], ([, allReady]) => {
@@ -592,8 +343,7 @@ class ArrayFieldComponent {
             .pipe(takeUntilDestroyed())
             .subscribe((action) => {
             if (action.action === 'add') {
-                // Template can be single FieldDef (primitive) or FieldDef[] (object)
-                const templates = Array.isArray(action.template) ? action.template : action.template ? [action.template] : [];
+                                const templates = Array.isArray(action.template) ? action.template : action.template ? [action.template] : [];
                 if (templates.length === 0) {
                     this.logger.error(`Cannot add item to array '${this.key()}': template is REQUIRED. ` +
                         'Buttons must specify an explicit template property. ' +
@@ -610,25 +360,11 @@ class ArrayFieldComponent {
             }
         });
     }
-    /**
-     * Handles add operations from events (append, prepend, insert).
-     * Creates resolved items FIRST, then updates form value.
-     * This ensures prepend/insert work correctly - differential update sees "none"
-     * because resolved items count already matches the new array length.
-     *
-     * Supports both primitive (single FieldDef) and object (FieldDef[]) templates.
-     */
-    async handleAddFromEvent(template, index) {
-        // Normalize template to mutable array for consistent handling.
-        // A single FieldDef with valueHandling: 'flatten' (container, row) is an object item
-        // whose children should be flattened — NOT a primitive item. Only true leaf fields
-        // (input, checkbox, etc.) are primitive when passed as a single FieldDef.
-        const templates = Array.isArray(template) ? [...template] : [template];
+        async handleAddFromEvent(template, index) {
+                                        const templates = Array.isArray(template) ? [...template] : [template];
         const isSingleField = !Array.isArray(template);
         const isPrimitiveItem = isSingleField && getFieldValueHandling(templates[0].type, this.rawFieldRegistry()) !== 'flatten';
-        // Track primitive field key for full-API arrays that start empty.
-        // Simplified arrays already have this info from normalization metadata.
-        if (isPrimitiveItem && templates[0].key && !this.primitiveFieldKey()) {
+                        if (isPrimitiveItem && templates[0].key && !this.primitiveFieldKey()) {
             this.primitiveFieldKey.set(templates[0].key);
         }
         if (templates.length === 0) {
@@ -641,27 +377,22 @@ class ArrayFieldComponent {
         const currentValue = parentForm().value();
         const currentArray = getArrayValue(currentValue, arrayKey);
         const insertIndex = index !== undefined ? Math.min(index, currentArray.length) : currentArray.length;
-        // Compute default value
-        let value;
+                let value;
         if (isPrimitiveItem) {
-            // Primitive item: single field's value is extracted directly
-            value = getFieldDefaultValue(templates[0], this.rawFieldRegistry());
+                        value = getFieldDefaultValue(templates[0], this.rawFieldRegistry());
         }
         else {
-            // Object item: merge all template defaults into an object
-            value = {};
+                        value = {};
             for (const templateField of templates) {
                 const rawValue = getFieldDefaultValue(templateField, this.rawFieldRegistry());
                 const valueHandling = getFieldValueHandling(templateField.type, this.rawFieldRegistry());
                 const isContainer = templateField.type === 'group' || templateField.type === 'row' || templateField.type === 'container';
                 if (isContainer) {
                     if (isGroupField(templateField)) {
-                        // Groups wrap their fields under the group key
-                        value = { ...value, [templateField.key]: rawValue };
+                                                value = { ...value, [templateField.key]: rawValue };
                     }
                     else {
-                        // Rows and containers flatten their fields directly
-                        value = { ...value, ...rawValue };
+                                                value = { ...value, ...rawValue };
                     }
                 }
                 else if (valueHandling === 'include' && templateField.key) {
@@ -669,13 +400,9 @@ class ArrayFieldComponent {
                 }
             }
         }
-        // Dispatch an append run — bumps runId so any in-flight differential update
-        // becomes stale, but state stays in its current phase.
-        const run = this.fsm.dispatch({ kind: 'append' });
-        // Append auto-remove button to resolution templates (for rendering only)
-        const resolveTemplates = this.withAutoRemove(templates);
-        // Resolve the new item
-        const resolvedItem = await firstValueFrom(resolveArrayItem({
+                        const run = this.fsm.dispatch({ kind: 'append' });
+                const resolveTemplates = this.withAutoRemove(templates);
+                const resolvedItem = await firstValueFrom(resolveArrayItem({
             index: insertIndex,
             templates: resolveTemplates,
             arrayField: this.field(),
@@ -694,52 +421,35 @@ class ArrayFieldComponent {
         if (run.isStale() || !resolvedItem) {
             return;
         }
-        // Store the template used for this item so it can be re-used during recreate operations
-        this.slot().templates.set(resolvedItem.id, templates);
-        // Mirror the insert into slot.itemOrder so survival across hide/show stays consistent.
-        this.slot().itemOrder.splice(insertIndex, 0, resolvedItem.id);
-        // Insert resolved item at correct position
-        this.resolvedItemsSignal.update((current) => {
+                this.slot().templates.set(resolvedItem.id, templates);
+                this.slot().itemOrder.splice(insertIndex, 0, resolvedItem.id);
+                this.resolvedItemsSignal.update((current) => {
             const newItems = [...current];
             newItems.splice(insertIndex, 0, resolvedItem);
             return newItems;
         });
-        // Update form value - differential update sees "none" (lengths match)
-        const newArray = [...currentArray];
+                const newArray = [...currentArray];
         newArray.splice(insertIndex, 0, value);
-        // The `as any` is required because Angular Signal Forms uses complex conditional types
-        // that cannot infer the correct type when setting a dynamically-keyed property
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
+                                parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
     }
     performDifferentialUpdate(fieldTrees) {
         const resolvedItems = this.resolvedItemsSignal();
         const operation = determineDifferentialOperation(resolvedItems, fieldTrees.length);
-        // "none" operations (value-only changes) don't kick the state machine — they shouldn't
-        // interfere with in-flight async resolutions.
-        if (operation.type === 'none') {
+                        if (operation.type === 'none') {
             return;
         }
         switch (operation.type) {
             case 'clear': {
-                // Clean up template registry when all items are removed
-                this.slot().templates.clear();
+                                this.slot().templates.clear();
                 this.resolvedItemsSignal.set([]);
                 const run = this.fsm.dispatch({ kind: 'clear' });
-                // First-ever clear with no items: synthesize a resolve so the emit-effect fires
-                // the init pulse (matches the form-starts-empty case from the prior implementation).
-                if (resolvedItems.length === 0 && !this.fsm.hasEverEmitted) {
+                                                if (resolvedItems.length === 0 && !this.fsm.hasEverEmitted) {
                     run.resolve();
                 }
                 break;
             }
             case 'initial': {
-                // If the slot has surviving state from a prior ArrayFieldComponent instance (same
-                // form, same array path, just a different render cycle — e.g. an `@if`-gated array
-                // that was hidden then re-shown), reuse the stored templates AND ids so dynamically-
-                // added items rebuild correctly. When the slot is empty this collapses to a normal
-                // initial resolve via Priority 2/3.
-                const slot = this.slot();
+                                                                                                const slot = this.slot();
                 const useSurvival = slot.itemOrder.length === fieldTrees.length && fieldTrees.length > 0;
                 const positionalTemplates = useSurvival ? slot.itemOrder.map((id) => slot.templates.get(id)) : undefined;
                 const existingItemIds = useSurvival ? slot.itemOrder.slice() : undefined;
@@ -753,13 +463,8 @@ class ArrayFieldComponent {
                 break;
             }
             case 'recreate': {
-                // Capture templates by item ID so each item is recreated with its original template,
-                // even after move operations that change positions. Registry entries (from dynamic adds
-                // or moves) take priority over positional itemTemplates lookup.
-                const positionalTemplates = resolvedItems.map((item) => {
-                    // Registry entries (from dynamic adds or moves) take priority;
-                    // unmoved initial items return undefined → falls through to itemTemplates[idx] during resolve.
-                    return this.slot().templates.get(item.id);
+                                                                const positionalTemplates = resolvedItems.map((item) => {
+                                                            return this.slot().templates.get(item.id);
                 });
                 this.resolvedItemsSignal.set([]);
                 const run = this.fsm.dispatch({ kind: 'recreate' });
@@ -773,18 +478,15 @@ class ArrayFieldComponent {
             this.resolvedItemsSignal.set([]);
             return;
         }
-        // Wrap each item observable to catch individual errors
-        const safeItemObservables = fieldTrees.map((_, i) => this.createResolveItemObservable(i, positionalTemplates?.[i], existingItemIds?.[i]).pipe(catchError((error) => {
+                const safeItemObservables = fieldTrees.map((_, i) => this.createResolveItemObservable(i, positionalTemplates?.[i], existingItemIds?.[i]).pipe(catchError((error) => {
             this.logger.error(`Failed to resolve array item at index ${i}:`, error);
             return of(undefined);
         })));
         try {
             const items = await firstValueFrom(forkJoin(safeItemObservables).pipe(map((items) => items.filter((item) => item !== undefined))));
             if (!run.isStale()) {
-                // Update template registry with new item IDs for dynamically added items
-                if (positionalTemplates) {
-                    // Clean up old entries and add new ones
-                    const newItemIds = new Set(items.map((item) => item.id));
+                                if (positionalTemplates) {
+                                        const newItemIds = new Set(items.map((item) => item.id));
                     for (const existingId of this.slot().templates.keys()) {
                         if (!newItemIds.has(existingId)) {
                             this.slot().templates.delete(existingId);
@@ -797,15 +499,12 @@ class ArrayFieldComponent {
                         }
                     });
                 }
-                // Mirror the resolved item ids into the slot's itemOrder so a future component
-                // recreate (e.g. after an @if hide cycle) can rehydrate via the survival path.
-                const slot = this.slot();
+                                                const slot = this.slot();
                 slot.itemOrder.length = 0;
                 for (const item of items)
                     slot.itemOrder.push(item.id);
                 this.resolvedItemsSignal.set(items);
-                // Mark this run settled so the emit-effect can fire componentInitialized once allReady is true.
-                run.resolve();
+                                run.resolve();
             }
         }
         catch (err) {
@@ -817,8 +516,7 @@ class ArrayFieldComponent {
         const itemsToResolve = fieldTrees.slice(startIndex, endIndex);
         if (itemsToResolve.length === 0)
             return;
-        // Wrap each item observable to catch individual errors
-        const safeItemObservables = itemsToResolve.map((_, i) => {
+                const safeItemObservables = itemsToResolve.map((_, i) => {
             const index = startIndex + i;
             return this.createResolveItemObservable(index).pipe(catchError((error) => {
                 this.logger.error(`Failed to resolve array item at index ${index}:`, error);
@@ -838,24 +536,10 @@ class ArrayFieldComponent {
             this.logger.error('Failed to append array items:', err);
         }
     }
-    /**
-     * Creates an observable that resolves a single array item.
-     *
-     * Template resolution order:
-     * 1. Use overrideTemplate if provided (from recreate with stored templates)
-     * 2. Use itemTemplates[index] if within defined templates range
-     * 3. Use the simplified-array fallback template (from normalization metadata) for
-     *    untracked items present in the form value (e.g., external `value.set`, parent
-     *    two-way binding, initial values beyond what was declared via simplified `value`).
-     *    Registers the resolved item in templateRegistry so subsequent recreates use
-     *    Priority 1.
-     * 4. Return undefined (item cannot be resolved without a template)
-     */
-    createResolveItemObservable(index, overrideTemplate, existingItemId) {
+        createResolveItemObservable(index, overrideTemplate, existingItemId) {
         const itemTemplates = this.itemTemplates();
         const primitiveKey = this.primitiveFieldKey();
-        // Priority 1: Use override template (from recreate with stored templates)
-        if (overrideTemplate && overrideTemplate.length > 0) {
+                if (overrideTemplate && overrideTemplate.length > 0) {
             return resolveArrayItem({
                 index,
                 templates: this.withAutoRemove(overrideTemplate),
@@ -871,8 +555,7 @@ class ArrayFieldComponent {
                 primitiveFieldKey: primitiveKey,
             });
         }
-        // Priority 2: Use defined template at this index
-        const templates = itemTemplates[index];
+                const templates = itemTemplates[index];
         if (templates && templates.length > 0) {
             return resolveArrayItem({
                 index,
@@ -889,9 +572,7 @@ class ArrayFieldComponent {
                 primitiveFieldKey: primitiveKey,
             });
         }
-        // Priority 3: Use the metadata fallback template for untracked items in the form value.
-        // Homogeneous only — every fallback item receives the same template regardless of value shape.
-        const fallback = this.fallbackTemplate();
+                        const fallback = this.fallbackTemplate();
         if (fallback && fallback.length > 0) {
             return resolveArrayItem({
                 index,
@@ -907,32 +588,14 @@ class ArrayFieldComponent {
                 existingItemId,
                 primitiveFieldKey: primitiveKey,
             }).pipe(tap((item) => {
-                // Register the fallback template against the generated item id so subsequent
-                // recreates hit Priority 1 instead of re-resolving via this branch.
-                if (item)
+                                                if (item)
                     this.slot().templates.set(item.id, fallback);
             }));
         }
-        // Priority 4: no template available. Full-API arrays are positional by design —
-        // `fields` declares one template per item, so values extending past `fields.length`
-        // (e.g., from external `value.set`, parent two-way binding, or initial values on a
-        // `fields: []` array) have no template to render. Use the simplified array API
-        // (`template` + `value`) when you need homogeneous arrays with value-driven items.
-        this.logger.warn(`No template found for array item at index ${index}. This likely occured for a Full-API array element that was created from the DynamicForm's value being set directly, which is currently not supported. Consider using the simplified array API.`);
+                                                this.logger.warn(`No template found for array item at index ${index}. This likely occured for a Full-API array element that was created from the DynamicForm's value being set directly, which is currently not supported. Consider using the simplified array API.`);
         return of(undefined);
     }
-    /**
-     * Appends the auto-remove button to a templates array for rendering.
-     * The button is added for visual rendering only — it doesn't affect the form schema.
-     * Original templates are stored in templateRegistry WITHOUT the remove button,
-     * so this method is called during resolution to add it dynamically.
-     *
-     * Uses a WeakMap cache keyed by template array reference. Cache hits occur
-     * during recreate/resolution paths where stored templates are reused.
-     * Add operations always pass a fresh `[...template]` copy, so they miss
-     * the cache intentionally (the copy is needed for mutable item construction).
-     */
-    withAutoRemove(templates) {
+        withAutoRemove(templates) {
         const removeButton = this.autoRemoveButton();
         if (!removeButton)
             return templates;
@@ -943,15 +606,7 @@ class ArrayFieldComponent {
         this.autoRemoveCache.set(templates, cached);
         return cached;
     }
-    /**
-     * Handles move operations — reorders an existing item without destroying it.
-     * Updates resolvedItems and form value atomically. Since the array length
-     * doesn't change, `determineDifferentialOperation` returns 'none' and no
-     * recreate is triggered. The `@for` loop tracks by `item.id`, so Angular
-     * moves the DOM node instead of destroying/recreating. The `itemPositionMap`
-     * computed auto-recomputes, propagating new indices to child linkedSignals.
-     */
-    moveItem(fromIndex, toIndex) {
+        moveItem(fromIndex, toIndex) {
         const arrayKey = this.field().key;
         const parentForm = this.parentFieldSignalContext.form;
         const currentValue = parentForm().value();
@@ -967,14 +622,7 @@ class ArrayFieldComponent {
         }
         if (fromIndex === toIndex)
             return;
-        // Register raw (pre-auto-remove) templates for all items whose position will change.
-        // Initial items use itemTemplates[currentIndex] during recreate, but after
-        // a move their position no longer matches their original template. Stashing
-        // the template by item ID lets the recreate path resolve the correct one.
-        // We use rawItemTemplates (without auto-remove button) because the recreate path
-        // calls withAutoRemove() during resolution — storing the synthesized version would
-        // cause duplicate remove buttons.
-        const rawTemplates = this.rawItemTemplates();
+                                                                const rawTemplates = this.rawItemTemplates();
         const currentItems = this.resolvedItemsSignal();
         const lo = Math.min(fromIndex, toIndex);
         const hi = Math.max(fromIndex, toIndex);
@@ -984,37 +632,26 @@ class ArrayFieldComponent {
                 this.slot().templates.set(item.id, rawTemplates[i]);
             }
         }
-        // Reorder resolvedItems — splice preserves object identity (no destroy/recreate)
-        this.resolvedItemsSignal.update((current) => {
+                this.resolvedItemsSignal.update((current) => {
             const newItems = [...current];
             const [moved] = newItems.splice(fromIndex, 1);
             newItems.splice(toIndex, 0, moved);
             return newItems;
         });
-        // Keep slot.itemOrder in sync so the post-recreate survival path sees the moved order.
-        this.slot().moveItem(fromIndex, toIndex);
-        // Reorder form value array the same way
-        const newArray = [...currentArray];
+                this.slot().moveItem(fromIndex, toIndex);
+                const newArray = [...currentArray];
         const [movedValue] = newArray.splice(fromIndex, 1);
         newArray.splice(toIndex, 0, movedValue);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
+                parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
     }
-    /**
-     * Handles remove operations from events (pop, shift, removeAt).
-     * Updates resolvedItems FIRST, then form value - this ensures differential
-     * update sees "none" (lengths match) and avoids unnecessary recreates.
-     * Remaining items' linkedSignal indices auto-update via itemPositionMap.
-     */
-    removeItem(index) {
+        removeItem(index) {
         const arrayKey = this.field().key;
         const parentForm = this.parentFieldSignalContext.form;
         const currentValue = parentForm().value();
         const currentArray = getArrayValue(currentValue, arrayKey);
         if (currentArray.length === 0)
             return;
-        // When index is undefined or -1, remove the last item.
-        let removeIndex;
+                let removeIndex;
         if (index === undefined || index === -1) {
             removeIndex = currentArray.length - 1;
         }
@@ -1025,33 +662,19 @@ class ArrayFieldComponent {
         else {
             removeIndex = index;
         }
-        // Update resolvedItems FIRST - remove the item at the specified index.
-        // This ensures differential update sees "none" (lengths already match).
-        // Remaining items' linkedSignal indices auto-update via itemPositionMap.
-        //
-        // When the item is removed from resolvedItemsSignal, the @for loop removes the DOM element
-        // and NgComponentOutlet destroys the component view, triggering DestroyRef callbacks.
-        // Async validators use Angular's resource API tied to the form-level schema path — when the
-        // array value is updated below, the resource's params re-evaluate. If the removed item's path
-        // no longer exists, params returns undefined, cancelling the pending validation automatically.
-        const removedItem = this.resolvedItemsSignal()[removeIndex];
+                                                                                const removedItem = this.resolvedItemsSignal()[removeIndex];
         if (removedItem) {
             this.slot().templates.delete(removedItem.id);
         }
-        // Keep slot.itemOrder in sync so the post-recreate survival path doesn't try to
-        // restore an id that's no longer in the form value.
-        this.slot().removeAt(removeIndex);
+                        this.slot().removeAt(removeIndex);
         this.resolvedItemsSignal.update((current) => {
             const newItems = [...current];
             newItems.splice(removeIndex, 1);
             return newItems;
         });
-        // Update the parent form with the new array value
-        const newArray = [...currentArray];
+                const newArray = [...currentArray];
         newArray.splice(removeIndex, 1);
-        // The `as any` is required due to Angular Signal Forms' complex conditional types
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
+                        parentForm().value.set({ ...currentValue, [arrayKey]: newArray });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ArrayFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: ArrayFieldComponent, isStandalone: true, selector: "array-field", inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, key: { classPropertyName: "key", publicName: "key", isSignal: true, isRequired: true, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class": "hostClasses()", "class.df-container-hidden": "hidden()", "attr.aria-hidden": "hidden() || null", "id": "`${key()}`", "attr.data-testid": "key()" } }, ngImport: i0, template: `
@@ -1100,4 +723,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
         }], ctorParameters: () => [], propDecorators: { field: [{ type: i0.Input, args: [{ isSignal: true, alias: "field", required: true }] }], key: [{ type: i0.Input, args: [{ isSignal: true, alias: "key", required: true }] }], className: [{ type: i0.Input, args: [{ isSignal: true, alias: "className", required: false }] }], hidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "hidden", required: false }] }] } });
 
 export { ArrayFieldComponent, ArrayFieldComponent as default };
-//# sourceMappingURL=ng-forge-dynamic-forms-array-field.component-GiaVHO9N.mjs.map
+//# sourceMappingURL=ng-forge-dynamic-forms-array-field.component-D6GEsH72.mjs.map