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

package/fesm2022/ng-forge-dynamic-forms-integration.mjs

@@ -9,47 +9,18 @@ import { explicitEffect } from 'ngxtension/explicit-effect';
 import { TestBed } from '@angular/core/testing';
 import { form, schema } from '@angular/forms/signals';
 
-/**
- * Creates a value field context from the injected FIELD_SIGNAL_CONTEXT.
- * Must be called within an injection context.
- *
- * With direct root form binding for array items, the FIELD_SIGNAL_CONTEXT.form
- * uses a getter that evaluates reactively. This means:
- * - For regular fields: direct access to the form's FieldTree
- * - For array items: the getter resolves rootForm['arrayKey'][index] dynamically
- *
- * The returned context provides a getFieldTree function that should be called
- * inside a computed to establish proper reactive dependencies.
- *
- * @returns The value field context with reactive field tree accessor
- */
 function resolveValueFieldContext() {
     const context = injectFieldSignalContext();
     return {
         getFieldTree: (fieldKey) => {
-            // Access context.form here (inside a function that will be called from a computed)
-            // This allows the getter to be evaluated reactively
-            const formRoot = context.form;
-            // Handle case where form is undefined (e.g., newly added array items before root form updates)
-            if (!formRoot) {
+                                    const formRoot = context.form;
+                        if (!formRoot) {
                 return undefined;
             }
             return formRoot[fieldKey];
         },
     };
 }
-/**
- * Builds the base inputs for a value field.
- * This is a helper function used by valueFieldMapper and specialized mappers.
- *
- * Note: This function should be called inside a computed signal to ensure
- * proper reactive dependency tracking for the field tree resolution.
- *
- * @param fieldDef The value field definition
- * @param ctx The resolved value field context
- * @param defaultProps Default props from the form configuration (may be undefined if not configured)
- * @returns Record of input names to values
- */
 function buildValueFieldInputs(fieldDef, ctx, defaultProps) {
     const omittedFields = omit(fieldDef, ['value']);
     const baseInputs = buildBaseInputs(omittedFields, defaultProps);
@@ -60,56 +31,20 @@ function buildValueFieldInputs(fieldDef, ctx, defaultProps) {
     if (fieldDef.placeholder !== undefined) {
         inputs['placeholder'] = fieldDef.placeholder;
     }
-    // Resolve field tree reactively - this call is inside a computed,
-    // so it establishes the reactive dependency correctly
-    const fieldTree = ctx.getFieldTree(fieldDef.key);
+            const fieldTree = ctx.getFieldTree(fieldDef.key);
     if (fieldTree !== undefined) {
         inputs['field'] = fieldTree;
     }
     return inputs;
 }
-/**
- * Maps a value field definition to component inputs.
- *
- * Value fields are input fields that contribute to the form's value (text, number, etc.).
- * This mapper injects FIELD_SIGNAL_CONTEXT to access the form structure and retrieve the field proxy.
- *
- * For array items, the FIELD_SIGNAL_CONTEXT.form uses a reactive getter that resolves
- * rootForm['arrayKey'][index] dynamically. This means:
- * - Zod/StandardSchema validation errors are automatically available
- * - The field tree updates reactively when the root form structure changes
- * - Newly added array items will get their field tree once the form value updates
- *
- * For fields with specific properties, use the specialized mappers:
- * - optionsFieldMapper: for fields with options (select, radio, multi-checkbox)
- * - datepickerFieldMapper: for fields with minDate, maxDate, startAt
- * - checkboxFieldMapper: for boolean fields (checkbox, toggle)
- *
- * @param fieldDef The value field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function valueFieldMapper(fieldDef) {
-    // Get the context once at injection time (captures the FIELD_SIGNAL_CONTEXT reference)
-    const ctx = resolveValueFieldContext();
+        const ctx = resolveValueFieldContext();
     const defaultProps = inject(DEFAULT_PROPS);
-    // The computed calls ctx.getFieldTree(fieldDef.key) inside, which:
-    // 1. Accesses context.form (triggering the getter for array items)
-    // 2. Returns the field tree if available, or undefined if not yet
-    // 3. Re-runs when the form structure updates (reactive dependency)
-    return computed(() => {
+                    return computed(() => {
         return buildValueFieldInputs(fieldDef, ctx, defaultProps());
     });
 }
 
-/**
- * Maps a checkbox/toggle field definition to component inputs.
- *
- * Checkbox fields are checked fields that contribute to the form's value as boolean.
- * This mapper injects FIELD_SIGNAL_CONTEXT to access the form structure and retrieve the field tree.
- *
- * @param fieldDef The checkbox field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function checkboxFieldMapper(fieldDef) {
     const context = injectFieldSignalContext();
     const defaultProps = inject(DEFAULT_PROPS);
@@ -123,9 +58,7 @@ function checkboxFieldMapper(fieldDef) {
         if (fieldDef.placeholder !== undefined) {
             inputs['placeholder'] = fieldDef.placeholder;
         }
-        // Access form inside computed for reactivity and to handle cases where
-        // form may not be immediately available (e.g., during array item initialization)
-        const formRoot = context.form;
+                        const formRoot = context.form;
         const fieldTree = formRoot?.[fieldDef.key];
         if (fieldTree !== undefined) {
             inputs['field'] = fieldTree;
@@ -134,10 +67,6 @@ function checkboxFieldMapper(fieldDef) {
     });
 }
 
-/**
- * Converts a date value (string, Date, or null) to a Date object or null.
- * This ensures UI libraries that expect Date objects receive the correct type.
- */
 function toDate(value) {
     if (value === null || value === undefined) {
         return null;
@@ -145,31 +74,15 @@ function toDate(value) {
     if (value instanceof Date) {
         return value;
     }
-    // Parse string to Date
-    const date = new Date(value);
+        const date = new Date(value);
     return isNaN(date.getTime()) ? null : date;
 }
-/**
- * Maps a datepicker field to component inputs.
- *
- * Extends the base value field mapper by adding datepicker-specific properties:
- * - minDate: Minimum selectable date
- * - maxDate: Maximum selectable date
- * - startAt: Initial date to display when opening the picker
- *
- * Date values are automatically converted from strings to Date objects
- * since UI libraries (Material, PrimeNG, etc.) expect Date objects.
- *
- * @param fieldDef The datepicker field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function datepickerFieldMapper(fieldDef) {
     const ctx = resolveValueFieldContext();
     const defaultProps = inject(DEFAULT_PROPS);
     return computed(() => {
         const inputs = buildValueFieldInputs(fieldDef, ctx, defaultProps());
-        // Add datepicker-specific properties, converting strings to Date objects
-        if (fieldDef.minDate !== undefined) {
+                if (fieldDef.minDate !== undefined) {
             inputs['minDate'] = toDate(fieldDef.minDate);
         }
         if (fieldDef.maxDate !== undefined) {
@@ -182,44 +95,22 @@ function datepickerFieldMapper(fieldDef) {
     });
 }
 
-/**
- * Maps a field with options (select, radio, multi-checkbox) to component inputs.
- *
- * Extends the base value field mapper by adding the options property.
- *
- * @param fieldDef The field definition with options
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function optionsFieldMapper(fieldDef) {
     const ctx = resolveValueFieldContext();
     const defaultProps = inject(DEFAULT_PROPS);
     return computed(() => {
-        // Cast to BaseValueField - safe because all FieldWithOptions types extend BaseValueField
-        const inputs = buildValueFieldInputs(fieldDef, ctx, defaultProps());
-        // Add options property
-        inputs['options'] = fieldDef.options;
+                const inputs = buildValueFieldInputs(fieldDef, ctx, defaultProps());
+                inputs['options'] = fieldDef.options;
         return inputs;
     });
 }
 
-/**
- * Maps a slider field to component inputs.
- *
- * Extends the base value field mapper by adding slider-specific properties:
- * - minValue: Minimum slider value
- * - maxValue: Maximum slider value
- * - step: Step increment for the slider
- *
- * @param fieldDef The slider field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function sliderFieldMapper(fieldDef) {
     const ctx = resolveValueFieldContext();
     const defaultProps = inject(DEFAULT_PROPS);
     return computed(() => {
         const inputs = buildValueFieldInputs(fieldDef, ctx, defaultProps());
-        // Add slider-specific properties (these are at field level, not in props)
-        if (fieldDef.minValue !== undefined) {
+                if (fieldDef.minValue !== undefined) {
             inputs['minValue'] = fieldDef.minValue;
         }
         if (fieldDef.maxValue !== undefined) {
@@ -232,10 +123,6 @@ function sliderFieldMapper(fieldDef) {
     });
 }
 
-/**
- * Applies hidden and disabled logic to a non-form-bound field.
- * Must be called inside a computed() context (reads form signals).
- */
 function applyNonFieldLogic(rootFormRegistry, fieldDef) {
     const result = {};
     const rootForm = rootFormRegistry.rootForm();
@@ -248,10 +135,8 @@ function applyNonFieldLogic(rootFormRegistry, fieldDef) {
             });
             result.hidden = hiddenSignal();
         }
-        // Resolve disabled state if explicitly set or has logic
-        if (fieldDef.disabled !== undefined || fieldDef.logic?.some((l) => l.type === 'disabled')) {
-            // Create the signal and READ IT to establish reactive dependencies
-            const disabledSignal = resolveNonFieldDisabled({
+                if (fieldDef.disabled !== undefined || fieldDef.logic?.some((l) => l.type === 'disabled')) {
+                        const disabledSignal = resolveNonFieldDisabled({
                 form: rootForm,
                 fieldLogic: fieldDef.logic,
                 explicitValue: fieldDef.disabled,
@@ -260,8 +145,7 @@ function applyNonFieldLogic(rootFormRegistry, fieldDef) {
         }
     }
     else {
-        // Fallback to static values when rootForm is not available
-        if (fieldDef.hidden !== undefined) {
+                if (fieldDef.hidden !== undefined) {
             result.hidden = fieldDef.hidden;
         }
         if (fieldDef.disabled !== undefined) {
@@ -270,19 +154,6 @@ function applyNonFieldLogic(rootFormRegistry, fieldDef) {
     }
     return result;
 }
-/**
- * Applies hidden logic to a non-form-bound field.
- *
- * This is a focused utility for fields that only need hidden state resolution.
- * Use this when you need hidden logic but handle disabled separately
- * (e.g., navigation buttons with custom disabled logic).
- *
- * NOTE: This function must be called inside a computed() context.
- *
- * @param rootForm The root form FieldTree (can be undefined)
- * @param fieldDef The field definition with optional hidden/logic
- * @returns The resolved hidden boolean value, or undefined if no hidden logic
- */
 function resolveHiddenValue(rootForm, fieldDef) {
     if (!rootForm) {
         return fieldDef.hidden;
@@ -292,71 +163,36 @@ function resolveHiddenValue(rootForm, fieldDef) {
             form: rootForm,
             fieldLogic: fieldDef.logic,
             explicitValue: fieldDef.hidden,
-            // formValue omitted intentionally - resolver will read form.value() reactively
-        })();
+                    })();
     }
     return undefined;
 }
 
-/**
- * Maps a button field to component inputs.
- *
- * Unlike value field mappers, button fields do not participate in form values
- * and do not need field tree resolution or validation messages.
- *
- * Button-specific properties:
- * - event: The FormEvent constructor to emit when clicked
- * - eventArgs: Optional arguments to pass to the event constructor
- *
- * Hidden and disabled states are resolved using non-field logic resolvers which consider:
- * 1. Explicit `hidden: true` / `disabled: true` on the field definition
- * 2. Field-level `logic` array with `type: 'hidden'` or `type: 'disabled'` conditions
- *
- * @param fieldDef The button field definition
- * @returns Signal containing Record of input names to values for ngComponentOutlet
- */
 function buttonFieldMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
     return computed(() => {
         const inputs = buildBaseInputs(fieldDef, defaultProps());
-        // Add button-specific properties
-        inputs['event'] = fieldDef.event;
+                inputs['event'] = fieldDef.event;
         if (fieldDef.eventArgs !== undefined) {
             inputs['eventArgs'] = fieldDef.eventArgs;
         }
-        // Apply hidden/disabled logic
-        return {
+                return {
             ...inputs,
             ...applyNonFieldLogic(rootFormRegistry, fieldDef),
         };
     });
 }
 
-/**
- * Resolves array button context for button mappers.
- *
- * Handles both inside-array (context from ARRAY_CONTEXT) and
- * outside-array (explicit arrayKey) placements.
- *
- * Must be called in injection context.
- *
- * @param fieldKey The button field key (for logging)
- * @param buttonType The button type name (for logging)
- * @param explicitArrayKey Optional explicit arrayKey from field definition
- * @returns The array button context with reactive index signal
- */
 function resolveArrayButtonContext(fieldKey, buttonType, explicitArrayKey) {
     const arrayContext = inject(ARRAY_CONTEXT, { optional: true });
     const logger = inject(DynamicFormLogger);
-    // Priority: explicit arrayKey from fieldDef > arrayKey from context
-    const targetArrayKey = explicitArrayKey ?? arrayContext?.arrayKey;
+        const targetArrayKey = explicitArrayKey ?? arrayContext?.arrayKey;
     if (!targetArrayKey) {
         logger.warn(`${buttonType} button "${fieldKey}" has no array context. ` +
             'Either place it inside an array field, or provide an explicit arrayKey property.');
     }
-    // Create index signal once at injection time - computed to track arrayContext.index changes
-    const indexSignal = computed(() => {
+        const indexSignal = computed(() => {
         if (!arrayContext)
             return -1;
         return arrayContext.index();
@@ -368,21 +204,10 @@ function resolveArrayButtonContext(fieldKey, buttonType, explicitArrayKey) {
         isInsideArray: arrayContext !== null,
     };
 }
-/**
- * Builds the event context passed to the button component.
- *
- * Should be called inside a computed to track index signal changes.
- *
- * @param fieldKey The button field key
- * @param ctx The resolved array button context
- * @param template Optional template for add operations (single field or array of fields)
- * @returns The event context for the button component
- */
 function buildArrayButtonEventContext(fieldKey, ctx, template) {
     const eventContext = {
         key: fieldKey,
-        index: ctx.indexSignal(), // Evaluated inside computed
-        arrayKey: ctx.targetArrayKey ?? '',
+        index: ctx.indexSignal(),         arrayKey: ctx.targetArrayKey ?? '',
         formValue: ctx.formValue,
     };
     if (template) {
@@ -390,24 +215,10 @@ function buildArrayButtonEventContext(fieldKey, ctx, template) {
     }
     return eventContext;
 }
-/**
- * Resolves eventArgs with defaults for array buttons.
- *
- * @param fieldEventArgs The eventArgs from field definition (may be undefined)
- * @param defaultEventArgs The default eventArgs to use if not specified
- * @returns The resolved eventArgs array
- */
 function resolveArrayButtonEventArgs(fieldEventArgs, defaultEventArgs = ['$arrayKey', '$template']) {
     return fieldEventArgs ?? defaultEventArgs;
 }
 
-// =============================================================================
-// Add Array Item Mappers
-// =============================================================================
-/**
- * Mapper for add array item button — appends new item to end of array.
- * Template is REQUIRED to define the field structure for new items.
- */
 function addArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -423,10 +234,6 @@ function addArrayItemButtonMapper(fieldDef) {
         };
     });
 }
-/**
- * Mapper for prepend array item button — inserts new item at beginning of array.
- * Template is REQUIRED to define the field structure for new items.
- */
 function prependArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -442,10 +249,6 @@ function prependArrayItemButtonMapper(fieldDef) {
         };
     });
 }
-/**
- * Mapper for insert array item button — inserts new item at specific index.
- * Template and index are REQUIRED.
- */
 function insertArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -461,21 +264,11 @@ function insertArrayItemButtonMapper(fieldDef) {
         };
     });
 }
-// =============================================================================
-// Remove Array Item Mappers
-// =============================================================================
-/**
- * Mapper for remove array item button.
- * Inside array: RemoveAtIndexEvent. Outside array: PopArrayItemEvent.
- */
 function removeArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
     const ctx = resolveArrayButtonContext(fieldDef.key, 'removeArrayItem', fieldDef.arrayKey);
-    // Choose event type based on context:
-    // - Inside array: RemoveAtIndexEvent (remove specific item)
-    // - Outside array: PopArrayItemEvent (remove last item)
-    const eventType = ctx.isInsideArray ? RemoveAtIndexEvent : PopArrayItemEvent;
+                const eventType = ctx.isInsideArray ? RemoveAtIndexEvent : PopArrayItemEvent;
     const defaultEventArgs = ctx.isInsideArray ? ['$arrayKey', '$index'] : ['$arrayKey'];
     return computed(() => {
         const baseInputs = buildBaseInputs(fieldDef, defaultProps?.());
@@ -488,7 +281,6 @@ function removeArrayItemButtonMapper(fieldDef) {
         };
     });
 }
-/** Mapper for pop array item button — removes the last item from array. */
 function popArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -504,7 +296,6 @@ function popArrayItemButtonMapper(fieldDef) {
         };
     });
 }
-/** Mapper for shift array item button — removes the first item from array. */
 function shiftArrayItemButtonMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -521,13 +312,6 @@ function shiftArrayItemButtonMapper(fieldDef) {
     });
 }
 
-// =============================================================================
-// Submit Button Mapper
-// =============================================================================
-/**
- * Mapper for submit button — configures native form submission via type="submit".
- * Triggers native form submission rather than dispatching events directly.
- */
 function submitButtonFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
     const defaultProps = inject(DEFAULT_PROPS);
@@ -536,8 +320,7 @@ function submitButtonFieldMapper(fieldDef) {
     return computed(() => {
         const baseInputs = buildBaseInputs(fieldDef, defaultProps());
         const rootForm = rootFormRegistry.rootForm();
-        // Use rootForm (not fieldSignalContext.form) — submit needs root form validity (#157)
-        const disabled = resolveSubmitButtonDisabled({
+                const disabled = resolveSubmitButtonDisabled({
             form: rootForm,
             formOptions: formOptions(),
             fieldLogic: fieldWithLogic.logic,
@@ -545,8 +328,7 @@ function submitButtonFieldMapper(fieldDef) {
         })();
         const inputs = {
             ...baseInputs,
-            // type="submit" triggers native form submission (no event dispatch needed)
-            props: { ...fieldDef.props, type: 'submit' },
+                        props: { ...fieldDef.props, type: 'submit' },
             disabled,
         };
         const hidden = resolveHiddenValue(rootForm, fieldWithLogic);
@@ -556,10 +338,6 @@ function submitButtonFieldMapper(fieldDef) {
         return inputs;
     });
 }
-// =============================================================================
-// Next Page Button Mapper
-// =============================================================================
-/** Mapper for next page button — preconfigures NextPageEvent. */
 function nextButtonFieldMapper(fieldDef) {
     const fieldSignalContext = injectFieldSignalContext();
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -587,10 +365,6 @@ function nextButtonFieldMapper(fieldDef) {
         return inputs;
     });
 }
-// =============================================================================
-// Previous Page Button Mapper
-// =============================================================================
-/** Mapper for previous page button — preconfigures PreviousPageEvent. */
 function previousButtonFieldMapper(fieldDef) {
     const defaultProps = inject(DEFAULT_PROPS);
     const rootFormRegistry = inject(RootFormRegistryService);
@@ -602,8 +376,7 @@ function previousButtonFieldMapper(fieldDef) {
             ...baseInputs,
             event: PreviousPageEvent,
         };
-        // Add disabled binding only if explicitly set by user
-        if (fieldDef.disabled !== undefined) {
+                if (fieldDef.disabled !== undefined) {
             inputs['disabled'] = fieldDef.disabled;
         }
         const hidden = resolveHiddenValue(rootForm, fieldWithLogic);
@@ -614,105 +387,48 @@ function previousButtonFieldMapper(fieldDef) {
     });
 }
 
-// Button field mapper (generic)
 
-// UI-specific field mappers
 
-/**
- * Factory function that creates a signal of resolved validation errors
- * Handles async resolution of DynamicText validation messages
- *
- * @param field - Signal containing FieldTree
- * @param validationMessages - Signal containing custom field-level validation messages
- * @param defaultValidationMessages - Signal containing default validation messages (fallback)
- * @param injector - Optional injector for DynamicText resolution
- * @returns Signal<ResolvedError[]> - Reactively resolved error messages
- *
- * @example
- * ```typescript
- * readonly resolvedErrors = createResolvedErrorsSignal(
- *   this.field,
- *   this.validationMessages,
- *   this.defaultValidationMessages
- * );
- * ```
- */
 function createResolvedErrorsSignal(field, validationMessages, defaultValidationMessages = signal(undefined), injector = inject(Injector)) {
-    // Get logger from injector
-    const logger = injector.get(DynamicFormLogger);
-    // Ensure validationMessages is never undefined (mappers pass {} if not defined)
-    const messages = computed(() => validationMessages() ?? {}, ...(ngDevMode ? [{ debugName: "messages" }] : /* istanbul ignore next */ []));
+        const logger = injector.get(DynamicFormLogger);
+        const messages = computed(() => validationMessages() ?? {}, ...(ngDevMode ? [{ debugName: "messages" }] : /* istanbul ignore next */ []));
     const defaultMessages = computed(() => defaultValidationMessages() ?? {}, ...(ngDevMode ? [{ debugName: "defaultMessages" }] : /* istanbul ignore next */ []));
-    // Create a computed signal that reads the actual errors from the field
-    // This ensures the signal tracks changes to field().errors(), not just the field reference
-    const errors = computed(() => {
+            const errors = computed(() => {
         const control = field()();
         return control.errors();
     }, ...(ngDevMode ? [{ debugName: "errors" }] : /* istanbul ignore next */ []));
-    // Convert signals to observables using toObservable with injector
-    const errors$ = toObservable(errors, { injector });
+        const errors$ = toObservable(errors, { injector });
     const messages$ = toObservable(messages, { injector });
     const defaultMessages$ = toObservable(defaultMessages, { injector });
-    // Combine observables and process errors
-    const resolvedErrors$ = combineLatest([errors$, messages$, defaultMessages$]).pipe(switchMap(([currentErrors, msgs, defaultMsgs]) => {
-        // No errors - return empty array
-        if (!currentErrors || currentErrors.length === 0) {
+        const resolvedErrors$ = combineLatest([errors$, messages$, defaultMessages$]).pipe(switchMap(([currentErrors, msgs, defaultMsgs]) => {
+                if (!currentErrors || currentErrors.length === 0) {
             return of([]);
         }
-        // Create observable for each error's resolved message
-        const errorResolvers = currentErrors.map((error) => resolveErrorMessage(error, msgs, defaultMsgs, injector, logger));
-        // Combine all error message observables into single array emission, filtering out nulls
-        return errorResolvers.length > 0
+                const errorResolvers = currentErrors.map((error) => resolveErrorMessage(error, msgs, defaultMsgs, injector, logger));
+                return errorResolvers.length > 0
             ? combineLatest(errorResolvers).pipe(map((errors) => errors.filter((e) => e !== null)))
             : of([]);
     }));
-    // Convert observable back to signal using toSignal with injector
-    // toSignal properly handles the injection context and manages subscriptions
-    return toSignal(resolvedErrors$, { initialValue: [], injector });
+            return toSignal(resolvedErrors$, { initialValue: [], injector });
 }
-/**
- * Resolves a single error message from DynamicText sources with fallback logic
- * Priority: field-level message → default message → error.message → no message (logs warning)
- *
- * The error.message fallback enables schema validation libraries (Zod, Valibot, etc.)
- * to provide their own messages without requiring explicit validationMessages configuration.
- * Users who want translations can still override by configuring validationMessages.
- *
- * @internal
- */
 function resolveErrorMessage(error, fieldMessages, defaultMessages, injector, logger) {
-    // Check for field-level custom message first
-    const fieldMessage = fieldMessages[error.kind];
-    // Fall back to default message if no field-level message exists
-    const defaultMessage = defaultMessages[error.kind];
-    // Determine which message to use: field-level → default → error.message (from schema validators)
-    const messageToUse = fieldMessage ?? defaultMessage ?? error.message;
-    // If no message found, log warning and return null (will be filtered out)
-    if (!messageToUse) {
+        const fieldMessage = fieldMessages[error.kind];
+        const defaultMessage = defaultMessages[error.kind];
+        const messageToUse = fieldMessage ?? defaultMessage ?? error.message;
+        if (!messageToUse) {
         logger.warn(`No validation message found for error kind "${error.kind}". ` +
             `Please provide a message via field-level validationMessages or form-level defaultValidationMessages.`);
         return of(null);
     }
-    // If using error.message directly (from schema validators), wrap in of() instead of dynamicTextToObservable
-    // error.message is always a plain string, not DynamicText
-    const isSchemaMessage = fieldMessage === undefined && defaultMessage === undefined;
+            const isSchemaMessage = fieldMessage === undefined && defaultMessage === undefined;
     const messageObservable = isSchemaMessage
-        ? of(messageToUse) // error.message is always string
-        : dynamicTextToObservable(messageToUse, injector);
-    // Apply parameter interpolation to support {{param}} syntax
-    return messageObservable.pipe(map((msg) => ({
+        ? of(messageToUse)         : dynamicTextToObservable(messageToUse, injector);
+        return messageObservable.pipe(map((msg) => ({
         kind: error.kind,
         message: interpolateParams(msg, error),
     })));
 }
 
-/**
- * Computed signal that determines if errors should be displayed.
- * Based on field's invalid, touched, and error count.
- *
- * @param field - Signal containing FieldTree
- * @returns Signal<boolean> - True if errors should be displayed
- */
 function shouldShowErrors(field) {
     return computed(() => {
         const fieldTree = field();
@@ -721,13 +437,6 @@ function shouldShowErrors(field) {
     });
 }
 
-/**
- * Resolve target set, compute combined attrs, apply via applyMetaToElement.
- * Target resolution is cached by selector identity — re-resolves only on
- * selector change or `dependents` change. afterRenderEffect is signal-tracked,
- * so the callback re-runs only when computeAttrs / dependents differ.
- * @internal
- */
 function applyTrackedAttrsToTargets(elementRef, computeAttrs, options = {}) {
     const appliedByElement = new WeakMap();
     let cachedSelector;
@@ -737,8 +446,7 @@ function applyTrackedAttrsToTargets(elementRef, computeAttrs, options = {}) {
     const warnedSelectors = isDevMode() ? new Set() : undefined;
     afterRenderEffect({
         write: () => {
-            // Read dependents first so afterRenderEffect tracks them.
-            const currentDeps = options.dependents?.map((d) => d());
+                        const currentDeps = options.dependents?.map((d) => d());
             const attrs = computeAttrs();
             const selector = (typeof options.selector === 'function' ? options.selector() : options.selector)?.trim() || undefined;
             const selectorChanged = selector !== cachedSelector;
@@ -749,11 +457,7 @@ function applyTrackedAttrsToTargets(elementRef, computeAttrs, options = {}) {
                 cachedTargets = selector ? Array.from(elementRef.nativeElement.querySelectorAll(selector)) : [elementRef.nativeElement];
             }
             previousDeps = currentDeps;
-            // Dev-mode safety net: selector typo or wrong descendant query leaves
-            // meta + aria unapplied. Warn the first time we'd apply non-empty attrs
-            // to zero matches for a given selector. Re-warns only when the selector
-            // string changes (so authors fixing one typo see the next).
-            if (warnedSelectors && selector && cachedTargets.length === 0 && attrs && Object.keys(attrs).length > 0) {
+                                                            if (warnedSelectors && selector && cachedTargets.length === 0 && attrs && Object.keys(attrs).length > 0) {
                 if (!warnedSelectors.has(selector)) {
                     warnedSelectors.add(selector);
                     const tag = elementRef.nativeElement.tagName.toLowerCase();
@@ -761,9 +465,7 @@ function applyTrackedAttrsToTargets(elementRef, computeAttrs, options = {}) {
                         `Check the selector for typos, or supply 'dependents' if the target is rendered after a signal emits.`);
                 }
             }
-            // Bail when attrs unchanged AND nothing structural moved — keeps repeated
-            // effect runs (driven by an unrelated tracked-signal flicker) cheap.
-            if (!selectorChanged && !depsChanged && isEqual(attrs, previousAttrs)) {
+                                    if (!selectorChanged && !depsChanged && isEqual(attrs, previousAttrs)) {
                 return;
             }
             previousAttrs = attrs;
@@ -774,58 +476,14 @@ function applyTrackedAttrsToTargets(elementRef, computeAttrs, options = {}) {
         },
     });
 }
-/**
- * Sets up automatic meta attribute tracking and application for wrapped components.
- *
- * This utility creates an `afterRenderEffect` that applies meta attributes to DOM elements
- * after Angular's render cycle. It efficiently tracks signal dependencies and only re-applies
- * when the meta signal or any dependent signals change.
- *
- * Use this instead of MutationObserver for better performance and integration with Angular's
- * change detection.
- *
- * @param elementRef - Reference to the host element
- * @param meta - Signal containing meta attributes to apply
- * @param options - Configuration options
- *
- * @example
- * ```typescript
- * // For a radio group with dynamic options
- * constructor() {
- *   setupMetaTracking(inject(ElementRef), this.meta, {
- *     selector: 'input[type="radio"]',
- *     dependents: [this.options]
- *   });
- * }
- *
- * // For a simple checkbox
- * constructor() {
- *   setupMetaTracking(inject(ElementRef), this.meta, {
- *     selector: 'input[type="checkbox"]'
- *   });
- * }
- *
- * // For Shadow DOM components (apply to host)
- * constructor() {
- *   setupMetaTracking(inject(ElementRef), this.meta);
- * }
- * ```
- */
 function setupMetaTracking(elementRef, meta, options) {
     applyTrackedAttrsToTargets(elementRef, () => meta(), { selector: options?.selector, dependents: options?.dependents });
 }
-/**
- * Marker-directive variant: writes parent meta + aria to resolved targets.
- * Parent aria wins on key collision. Internal to NgForgeControl/HostControl.
- * @internal
- */
 function setupMarkerAttrTracking(elementRef, parent, selector) {
     applyTrackedAttrsToTargets(elementRef, () => {
         const ariaRequired = parent.ariaRequired();
         const ariaDescribedBy = parent.ariaDescribedBy();
-        // Skip null aria-required/describedby so applyMetaToElement removes the
-        // attr (rather than serializing "null") on transitions.
-        return {
+                        return {
             ...(parent.meta() ?? {}),
             'aria-invalid': parent.ariaInvalid(),
             ...(ariaRequired === null ? {} : { 'aria-required': ariaRequired }),
@@ -834,17 +492,6 @@ function setupMarkerAttrTracking(elementRef, parent, selector) {
     }, { selector });
 }
 
-/**
- * Creates a signal that computes the aria-describedby value based on errors and hint state.
- * Errors take precedence over hints - when errors are displayed, the hint is hidden.
- * Only the first error is displayed (single error ID, not indexed).
- *
- * @param errorsToDisplay Signal containing the array of errors currently being displayed
- * @param errorId Signal containing the ID for the error element (single error only)
- * @param hintId Signal containing the ID for the hint element
- * @param hasHint Function that returns true if a hint is configured
- * @returns Signal containing the aria-describedby value or null
- */
 function createAriaDescribedBySignal(errorsToDisplay, errorId, hintId, hasHint) {
     return computed(() => {
         if (errorsToDisplay().length > 0) {
@@ -857,24 +504,7 @@ function createAriaDescribedBySignal(errorsToDisplay, errorId, hintId, hasHint)
     });
 }
 
-// Error display utilities for field components
 
-/**
- * Base directive composed into every ng-forge component via `hostDirectives`.
- * Owns the universal identity inputs (`key`, `className`) and the host
- * bindings that every field shape — value-bearing, action, future container —
- * shares: `[id]`, `[attr.data-testid]`, `[class]`.
- *
- * Shape-specific add-ons (`NgForgeField` for value fields, `NgForgeAction`
- * for actions) inject this directive and read `key()` / `className()` from
- * it. Source-of-truth concerns like `hidden` / `disabled` live on the add-on
- * because they vary by shape (value fields derive from `field()()`; actions
- * receive direct inputs).
- *
- * Selectorless — usage is exclusively via `hostDirectives`. Prefer the
- * `NG_FORGE_FIELD` / `NG_FORGE_ACTION` presets rather than composing Shell
- * directly.
- */
 class NgForgeFieldShell {
     key = input.required(...(ngDevMode ? [{ debugName: "key" }] : /* istanbul ignore next */ []));
     className = input('', ...(ngDevMode ? [{ debugName: "className" }] : /* istanbul ignore next */ []));
@@ -891,76 +521,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     },
                 }]
         }], propDecorators: { key: [{ type: i0.Input, args: [{ isSignal: true, alias: "key", required: true }] }], className: [{ type: i0.Input, args: [{ isSignal: true, alias: "className", required: false }] }] } });
-/** Input names forwarded onto `NgForgeFieldShell` via `hostDirectives`. */
 const NG_FORGE_FIELD_SHELL_INPUTS = ['key', 'className'];
 
-/**
- * Value-bearing add-on directive — composed alongside `NgForgeFieldShell` via
- * the `NG_FORGE_FIELD` preset. Owns the value/validation/aria plumbing every
- * value-bearing field needs.
- *
- * The Shell owns universal identity (`key`, `className`, `[id]`,
- * `[attr.data-testid]`, `[class]`); this directive injects Shell and adds
- * field-driven bindings (`[attr.hidden]`, `[attr.aria-disabled]`), the
- * standard value-field inputs (`field`, `label`, `placeholder`, `tabIndex`,
- * `props`, `meta`, `validationMessages`), the derived error/aria signals,
- * and the meta-tracking claim contract.
- *
- * @example
- * ```ts
- * \@Component({
- *   hostDirectives: NG_FORGE_FIELD,
- *   imports: [NgForgeControl, FormField],
- *   template: `
- *     <label [for]="ngf.key() + '-input'">{{ ngf.label() | dynamicText | async }}</label>
- *     <input ngForgeControl [id]="ngf.key() + '-input'" [formField]="ngf.field()" />
- *     @if (ngf.errorsToDisplay()[0]; as e) {
- *       <span [id]="ngf.errorId()">{{ e.message }}</span>
- *     }
- *   `,
- * })
- * export class MyInputField {
- *   protected readonly ngf = injectNgForgeField<string>();
- * }
- * ```
- *
- * Selectorless — usage is exclusively via `hostDirectives`. Prefer the
- * `NG_FORGE_FIELD` preset over composing this directive manually.
- */
 class NgForgeField {
-    // ───────────────────────────────────────────────────────────────────────────
-    // Shell-owned identity — re-exported so component templates keep using
-    // `ngf.key()` / `ngf.className()` without reaching for the Shell directly.
-    // ───────────────────────────────────────────────────────────────────────────
-    shell = inject(NgForgeFieldShell);
-    /** Shell-owned key, re-exported as plain `Signal<string>` so it doesn't get flagged by the host-directive input-lockstep assertion. */
-    key = this.shell.key;
-    /** Shell-owned className, re-exported as plain `Signal<string>` for the same reason. */
-    className = this.shell.className;
-    // ───────────────────────────────────────────────────────────────────────────
-    // Forwarded inputs — the value-field-specific subset of mapper output.
-    // ───────────────────────────────────────────────────────────────────────────
-    field = input.required(...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
+                    shell = inject(NgForgeFieldShell);
+        key = this.shell.key;
+        className = this.shell.className;
+                field = input.required(...(ngDevMode ? [{ debugName: "field" }] : /* istanbul ignore next */ []));
     label = input(...(ngDevMode ? [undefined, { debugName: "label" }] : /* istanbul ignore next */ []));
     placeholder = input(...(ngDevMode ? [undefined, { debugName: "placeholder" }] : /* istanbul ignore next */ []));
     tabIndex = input(...(ngDevMode ? [undefined, { debugName: "tabIndex" }] : /* istanbul ignore next */ []));
     props = input(...(ngDevMode ? [undefined, { debugName: "props" }] : /* istanbul ignore next */ []));
     meta = input(...(ngDevMode ? [undefined, { debugName: "meta" }] : /* istanbul ignore next */ []));
     validationMessages = input(...(ngDevMode ? [undefined, { debugName: "validationMessages" }] : /* istanbul ignore next */ []));
-    // ───────────────────────────────────────────────────────────────────────────
-    // Wiring
-    // ───────────────────────────────────────────────────────────────────────────
-    defaultValidationMessages = inject(DEFAULT_VALIDATION_MESSAGES, { optional: true }) ?? signal(undefined);
-    // ───────────────────────────────────────────────────────────────────────────
-    // Error display
-    // ───────────────────────────────────────────────────────────────────────────
-    errors = createResolvedErrorsSignal(this.field, this.validationMessages, this.defaultValidationMessages);
+                defaultValidationMessages = inject(DEFAULT_VALIDATION_MESSAGES, { optional: true }) ?? signal(undefined);
+                errors = createResolvedErrorsSignal(this.field, this.validationMessages, this.defaultValidationMessages);
     showErrors = shouldShowErrors(this.field);
     errorsToDisplay = computed(() => (this.showErrors() ? this.errors() : []), ...(ngDevMode ? [{ debugName: "errorsToDisplay" }] : /* istanbul ignore next */ []));
-    // ───────────────────────────────────────────────────────────────────────────
-    // Accessibility helpers
-    // ───────────────────────────────────────────────────────────────────────────
-    errorId = computed(() => `${this.key()}-error`, ...(ngDevMode ? [{ debugName: "errorId" }] : /* istanbul ignore next */ []));
+                errorId = computed(() => `${this.key()}-error`, ...(ngDevMode ? [{ debugName: "errorId" }] : /* istanbul ignore next */ []));
     hintId = computed(() => `${this.key()}-hint`, ...(ngDevMode ? [{ debugName: "hintId" }] : /* istanbul ignore next */ []));
     ariaInvalid = computed(() => {
         const state = this.field()();
@@ -970,21 +548,13 @@ class NgForgeField {
         return this.field()().required?.() === true ? true : null;
     }, ...(ngDevMode ? [{ debugName: "ariaRequired" }] : /* istanbul ignore next */ []));
     ariaDescribedBy = createAriaDescribedBySignal(this.errorsToDisplay, this.errorId, this.hintId, () => Boolean(this.props()?.hint));
-    // ───────────────────────────────────────────────────────────────────────────
-    // Claim tracking — markers and ambient sub-components flip this to true so
-    // dev-mode can warn when meta() is non-empty but nothing consumed it.
-    // ───────────────────────────────────────────────────────────────────────────
-    _claimed = signal(false, ...(ngDevMode ? [{ debugName: "_claimed" }] : /* istanbul ignore next */ []));
-    /** @internal Marker directives + ambient sub-components call this on construction. */
-    markClaimed() {
+                    _claimed = signal(false, ...(ngDevMode ? [{ debugName: "_claimed" }] : /* istanbul ignore next */ []));
+        markClaimed() {
         this._claimed.set(true);
     }
     logger = inject(DynamicFormLogger, { optional: true });
     constructor() {
-        // Dev-mode safety net: a mapper or template-author binds meta() but no
-        // NgForgeControl / NgForgeHostControl / ambient sub-component is in
-        // place to consume it. Fires at most once per directive instance.
-        if (isDevMode()) {
+                                if (isDevMode()) {
             let warned = false;
             afterRenderEffect({
                 write: () => {
@@ -996,8 +566,7 @@ class NgForgeField {
                     if (untracked(this._claimed))
                         return;
                     warned = true;
-                    // `untracked` safe — afterRenderEffect.write runs after first CD, so Shell's required `key` is bound (no NG0950).
-                    const key = untracked(this.key);
+                                        const key = untracked(this.key);
                     const message = `NgForgeField - meta() provided for field "${key}" but no NgForgeControl / NgForgeHostControl / ` +
                         `ambient sub-component claimed it. Meta will not be applied. ` +
                         `See https://ng-forge.dev/building-an-adapter#meta-forwarding`;
@@ -1023,70 +592,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     },
                 }]
         }], ctorParameters: () => [], propDecorators: { field: [{ type: i0.Input, args: [{ isSignal: true, alias: "field", required: true }] }], label: [{ type: i0.Input, args: [{ isSignal: true, alias: "label", required: false }] }], placeholder: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeholder", required: false }] }], tabIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "tabIndex", required: false }] }], props: [{ type: i0.Input, args: [{ isSignal: true, alias: "props", required: false }] }], meta: [{ type: i0.Input, args: [{ isSignal: true, alias: "meta", required: false }] }], validationMessages: [{ type: i0.Input, args: [{ isSignal: true, alias: "validationMessages", required: false }] }] } });
-/**
- * Inputs forwarded onto `NgForgeField` via `hostDirectives`. Excludes
- * `key` / `className` (forwarded to `NgForgeFieldShell` separately via
- * `NG_FORGE_FIELD_SHELL_INPUTS`). Most consumers shouldn't reference this
- * directly — use the `NG_FORGE_FIELD` preset.
- */
 const NG_FORGE_VALUE_FIELD_INPUTS = ['field', 'label', 'placeholder', 'tabIndex', 'props', 'meta', 'validationMessages'];
-// Compile-time lockstep: NG_FORGE_VALUE_FIELD_INPUTS must equal the declared
-// `input()` properties on NgForgeField. Drift in either direction fails the build.
 const _NG_FORGE_VALUE_FIELD_INPUTS_LOCKSTEP = true;
 void _NG_FORGE_VALUE_FIELD_INPUTS_LOCKSTEP;
-/**
- * Typed wrapper around `inject(NgForgeField)`. The generic narrows the
- * `field` signal to `Signal<FieldTree<T>>` for the calling component's value
- * type. The cast is unchecked — the runtime contract is that mappers only
- * forward a `field` whose value type matches the field-type definition.
- *
- * @example
- * ```ts
- * protected readonly ngf = injectNgForgeField<string>();
- * // ngf.field() is Signal<FieldTree<string>>; ngf.errors() etc. unchanged
- * ```
- */
 function injectNgForgeField() {
     return inject(NgForgeField);
 }
 
-/**
- * Action add-on directive — composed alongside `NgForgeFieldShell` via the
- * `NG_FORGE_ACTION` preset. Owns the inputs + dispatch logic every button /
- * action component needs (label, disabled, event, eventArgs, …) plus the
- * `[attr.hidden]` / `[attr.aria-disabled]` host bindings driven by its own
- * inputs (no field tree).
- *
- * Components call `action.dispatch()` from their click handler; this
- * directive resolves any `eventArgs` tokens via the optional `ARRAY_CONTEXT`
- * and dispatches the configured `event` through the `EventBus`.
- *
- * @example
- * ```ts
- * \@Component({
- *   hostDirectives: NG_FORGE_ACTION,
- *   template: `<button (click)="action.dispatch()" [disabled]="action.disabled()">{{ action.label() }}</button>`,
- * })
- * export class MyButton {
- *   protected readonly action = inject(NgForgeAction);
- * }
- * ```
- *
- * Selectorless — usage is exclusively via `hostDirectives`. Prefer the
- * `NG_FORGE_ACTION` preset over composing this directive manually.
- */
 class NgForgeAction {
-    // ───────────────────────────────────────────────────────────────────────────
-    // Shell-owned identity — re-exported as plain `Signal<T>` so they don't get
-    // flagged by the lockstep assertion below.
-    // ───────────────────────────────────────────────────────────────────────────
-    shell = inject(NgForgeFieldShell);
+                    shell = inject(NgForgeFieldShell);
     key = this.shell.key;
     className = this.shell.className;
-    // ───────────────────────────────────────────────────────────────────────────
-    // Forwarded inputs — the action-specific subset of mapper output.
-    // ───────────────────────────────────────────────────────────────────────────
-    label = input.required(...(ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []));
+                label = input.required(...(ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []));
     disabled = input(false, ...(ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []));
     hidden = input(false, ...(ngDevMode ? [{ debugName: "hidden" }] : /* istanbul ignore next */ []));
     tabIndex = input(...(ngDevMode ? [undefined, { debugName: "tabIndex" }] : /* istanbul ignore next */ []));
@@ -1094,19 +611,9 @@ class NgForgeAction {
     eventArgs = input(...(ngDevMode ? [undefined, { debugName: "eventArgs" }] : /* istanbul ignore next */ []));
     eventContext = input(...(ngDevMode ? [undefined, { debugName: "eventContext" }] : /* istanbul ignore next */ []));
     props = input(...(ngDevMode ? [undefined, { debugName: "props" }] : /* istanbul ignore next */ []));
-    // ───────────────────────────────────────────────────────────────────────────
-    // Dispatch
-    // ───────────────────────────────────────────────────────────────────────────
-    eventBus = inject(EventBus);
+                eventBus = inject(EventBus);
     arrayContext = inject(ARRAY_CONTEXT, { optional: true });
-    /**
-     * Dispatch the configured event through the EventBus. Resolves `eventArgs`
-     * tokens (`$key`, `$index`, `$arrayKey`, `formValue`, …) against the
-     * ambient array context if present, falling back to a static `eventContext`
-     * input or the field's own `key` otherwise. No-op when `event` is unset
-     * (e.g. submit buttons handled by the native form lifecycle).
-     */
-    dispatch() {
+        dispatch() {
         const event = this.event();
         if (!event)
             return;
@@ -1137,47 +644,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     },
                 }]
         }], propDecorators: { label: [{ type: i0.Input, args: [{ isSignal: true, alias: "label", required: true }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], hidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "hidden", required: false }] }], tabIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "tabIndex", required: false }] }], event: [{ type: i0.Input, args: [{ isSignal: true, alias: "event", required: false }] }], eventArgs: [{ type: i0.Input, args: [{ isSignal: true, alias: "eventArgs", required: false }] }], eventContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "eventContext", required: false }] }], props: [{ type: i0.Input, args: [{ isSignal: true, alias: "props", required: false }] }] } });
-/**
- * Inputs forwarded onto `NgForgeAction` via `hostDirectives`. Excludes
- * `key` / `className` (forwarded to `NgForgeFieldShell` separately via
- * `NG_FORGE_FIELD_SHELL_INPUTS`). Most consumers shouldn't reference this
- * directly — use the `NG_FORGE_ACTION` preset.
- */
 const NG_FORGE_ACTION_INPUTS = ['label', 'disabled', 'hidden', 'tabIndex', 'event', 'eventArgs', 'eventContext', 'props'];
-// Compile-time lockstep: NG_FORGE_ACTION_INPUTS must equal the declared
-// `input()` properties on NgForgeAction. Drift fails the build.
 const _NG_FORGE_ACTION_INPUTS_LOCKSTEP = true;
 void _NG_FORGE_ACTION_INPUTS_LOCKSTEP;
-/**
- * Typed wrapper around `inject(NgForgeAction)`. The generic narrows the
- * `event` input to a specific FormEvent subclass.
- *
- * @example
- * ```ts
- * protected readonly action = injectNgForgeAction<SubmitEvent>();
- * ```
- */
 function injectNgForgeAction() {
     return inject(NgForgeAction);
 }
 
-/**
- * Universal addon-array plumbing: signal-cached `hidden` resolution and
- * slot bucketing. Used internally by the `NgForgeAddons` host wrapper —
- * consumers should compose `NgForgeAddons` directly and inject the
- * directive instance via `injectNgForgeAddons<TAddon>()`.
- */
 class NgForgeAddonsBase {
-    /** Capture the host's injector so `toSignal` (inside `resolveDynamicValue`) ties to the host's `DestroyRef`. */
-    hostInjector = inject(Injector);
-    /** Addon array mapped from `FieldDef.addons` by `buildBaseInputs`. */
-    addons = input(undefined, ...(ngDevMode ? [{ debugName: "addons" }] : /* istanbul ignore next */ []));
-    /**
-     * Per-addon `hidden` signal cache. Built via `explicitEffect` rather
-     * than `computed` because `toSignal` (inside `resolveDynamicValue` for
-     * Observable inputs) is disallowed in reactive contexts (NG0602).
-     */
-    _hiddenSignalCache = signal(new Map(), ...(ngDevMode ? [{ debugName: "_hiddenSignalCache" }] : /* istanbul ignore next */ []));
+        hostInjector = inject(Injector);
+        addons = input(undefined, ...(ngDevMode ? [{ debugName: "addons" }] : /* istanbul ignore next */ []));
+        _hiddenSignalCache = signal(new Map(), ...(ngDevMode ? [{ debugName: "_hiddenSignalCache" }] : /* istanbul ignore next */ []));
     hiddenSignalCache = this._hiddenSignalCache.asReadonly();
     visibleAddons = computed(() => {
         const list = this.addons() ?? [];
@@ -1187,11 +664,7 @@ class NgForgeAddonsBase {
     hasAddons = computed(() => this.visibleAddons().length > 0, ...(ngDevMode ? [{ debugName: "hasAddons" }] : /* istanbul ignore next */ []));
     prefixAddons = computed(() => this.visibleAddons().filter((a) => a.slot === 'prefix'), ...(ngDevMode ? [{ debugName: "prefixAddons" }] : /* istanbul ignore next */ []));
     suffixAddons = computed(() => this.visibleAddons().filter((a) => a.slot === 'suffix'), ...(ngDevMode ? [{ debugName: "suffixAddons" }] : /* istanbul ignore next */ []));
-    /**
-     * Visible addons grouped by their `slot` string. Convenience view for
-     * adapters with non-universal slots (e.g., Ionic `start` / `end`).
-     */
-    addonsBySlot = computed(() => {
+        addonsBySlot = computed(() => {
         const map = new Map();
         for (const a of this.visibleAddons()) {
             const bucket = map.get(a.slot) ?? [];
@@ -1200,24 +673,15 @@ class NgForgeAddonsBase {
         }
         return map;
     }, ...(ngDevMode ? [{ debugName: "addonsBySlot" }] : /* istanbul ignore next */ []));
-    /** Secondary index keyed by `hidden` value identity. Catches the common case
-     *  where a FormConfig re-emit produces structurally-different-but-content-
-     *  identical addon objects — without this, every re-emit would spawn a new
-     *  `toSignal` subscription for each addon's hidden axis. */
-    _hiddenByValue = new WeakMap();
+        _hiddenByValue = new WeakMap();
     constructor() {
         explicitEffect([this.addons], ([list]) => {
             const prev = this._hiddenSignalCache();
             const next = new Map();
             for (const a of list ?? []) {
-                // Tier 1: reference identity — the cheapest hit when the same addon
-                // object is reused across emissions.
-                let resolved = prev.get(a);
+                                                let resolved = prev.get(a);
                 if (!resolved) {
-                    // Tier 2: hidden-value identity — when `hidden` is an object
-                    // (Signal / Observable / function), the same instance can be passed
-                    // through multiple new addon objects on FormConfig re-emit.
-                    const h = a.hidden;
+                                                                                const h = a.hidden;
                     const valueKey = typeof h === 'object' && h !== null ? h : null;
                     resolved = valueKey ? this._hiddenByValue.get(valueKey) : undefined;
                     if (!resolved) {
@@ -1238,36 +702,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             type: Directive,
             args: [{}]
         }], ctorParameters: () => [], propDecorators: { addons: [{ type: i0.Input, args: [{ isSignal: true, alias: "addons", required: false }] }] } });
-/** Forwarded onto `NgForgeAddonsBase` via the `NgForgeAddons` wrapper. */
 const NG_FORGE_ADDONS_INPUTS = ['addons'];
-// Compile-time lockstep — drift between the tuple and the declared inputs fails the build.
 const _NG_FORGE_ADDONS_INPUTS_LOCKSTEP = true;
 void _NG_FORGE_ADDONS_INPUTS_LOCKSTEP;
-/**
- * Host wrapper for `NgForgeAddonsBase`. Consumers compose this directly:
- *
- * ```ts
- * \@Component({
- *   hostDirectives: [NgForgeFieldHost, NgForgeAddons],
- *   template: `
- *     @if (ngfa.hasAddons()) {
- *       <p-inputgroup>
- *         @for (a of ngfa.prefixAddons(); track $index) {
- *           <df-addon-slot [addon]="a" [hidden]="ngfa.hiddenSignalCache().get(a)" />
- *         }
- *         <input ngForgeControl ... />
- *       </p-inputgroup>
- *     }
- *   `,
- * })
- * export class MyInputField {
- *   protected readonly ngfa = injectNgForgeAddons<MyInputAddon>();
- * }
- * ```
- *
- * The wrapper exists so `hostDirectives: [NgForgeAddons]` resolves
- * cross-package — same constraint that drives `NgForgeFieldHost`.
- */
 class NgForgeAddons {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgForgeAddons, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.14", type: NgForgeAddons, isStandalone: true, hostDirectives: [{ directive: NgForgeAddonsBase, inputs: ["addons", "addons"] }], ngImport: i0 });
@@ -1278,49 +715,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     hostDirectives: [{ directive: NgForgeAddonsBase, inputs: [...NG_FORGE_ADDONS_INPUTS] }],
                 }]
         }] });
-/**
- * Typed inject helper. Always resolves to the underlying
- * `NgForgeAddonsBase` instance — the wrapper class has no instance
- * fields of its own.
- */
 function injectNgForgeAddons() {
     return inject(NgForgeAddonsBase);
 }
 
 const ADDON_PRESET_HANDLER = new InjectionToken('ADDON_PRESET_HANDLER');
 
-/**
- * Universal click-dispatch plumbing for action-style addons (icon buttons,
- * labelled buttons, etc.): `disabled` / `loading` resolution from
- * `DynamicValue<boolean>`, action context construction, and the
- * `preset / actionRef / action` precedence dispatcher.
- *
- * Adapter button kinds (e.g., `prime-button`) compose `NgForgeAddonAction`
- * and read state via `injectNgForgeAddonAction<TAddon>()`. Preset semantics
- * are adapter-specific — register an `ADDON_PRESET_HANDLER` at the host
- * field scope to receive preset dispatches.
- */
 class NgForgeAddonActionBase {
-    // The action registry is form-scoped. `optional: true` matches the
-    // preset handler so addons rendered outside a form that called
-    // `provideAddonActions(...)` degrade gracefully instead of throwing —
-    // `actionRef` dispatches then log an actionable warning and no-op.
-    actionRegistry = inject(ADDON_ACTION_REGISTRY, { optional: true });
+                    actionRegistry = inject(ADDON_ACTION_REGISTRY, { optional: true });
     presetHandler = inject(ADDON_PRESET_HANDLER, { optional: true });
     logger = inject(DynamicFormLogger);
     hostInjector = inject(Injector);
     addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
     fieldInputs = input(undefined, ...(ngDevMode ? [{ debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
-    /**
-     * Per-value caches for `disabled` / `loading` signal resolution. Keyed by
-     * the `DynamicValue` identity so a single `toSignal` subscription is
-     * shared across addon-reference swaps that pass the same Observable.
-     * Mirrors `NgForgeAddonsBase._hiddenByValue` — `resolveDynamicValue`
-     * cannot run inside `computed`/`linkedSignal.computation` because
-     * `toSignal` throws in reactive contexts (NG0602), and re-running it on
-     * every recomputation would leak subscriptions on each cycle.
-     */
-    _disabledByValue = new WeakMap();
+        _disabledByValue = new WeakMap();
     _loadingByValue = new WeakMap();
     _resolvedDisabled = signal(undefined, ...(ngDevMode ? [{ debugName: "_resolvedDisabled" }] : /* istanbul ignore next */ []));
     _resolvedLoading = signal(undefined, ...(ngDevMode ? [{ debugName: "_resolvedLoading" }] : /* istanbul ignore next */ []));
@@ -1342,13 +750,7 @@ class NgForgeAddonActionBase {
         }
         return resolved;
     }
-    /**
-     * Resolve the click handler from the addon's three-axis click variant and
-     * invoke it. Precedence on multi-set: `preset > actionRef > action`. The
-     * validator drops multi-set configs at config-init time; this is
-     * defence-in-depth + a logged warning so the misconfiguration is loud.
-     */
-    dispatch() {
+        dispatch() {
         const addon = this.addon();
         const ctx = this.buildActionContext();
         const variantsSet = [addon.preset, addon.actionRef, addon.action].filter((v) => v !== undefined).length;
@@ -1380,39 +782,14 @@ class NgForgeAddonActionBase {
             addon.action(ctx);
             return;
         }
-        // Decorative — no handler configured.
-    }
-    /**
-     * Build an `AddonActionContext` for handlers from the wrapper-style
-     * `fieldInputs` bag. Returns the field-bound variant when a host field
-     * is reachable, or the orphan variant otherwise.
-     *
-     * Resolution order for `setValue`:
-     * 1. `inputs.setValue` from the forwarded bag (preferred — populated by
-     *    `buildFieldInputs` in `DfFieldOutlet`).
-     * 2. Fallback reconstructed from `inputs.field` itself: although
-     *    `ReadonlyFieldTree.value` is type-narrowed to `Signal<T>`, the
-     *    underlying runtime object is the same `WritableSignal<T>` created
-     *    by Signal Forms (the read-only wrapping is type-level only, see
-     *    `toReadonlyFieldTree`). Casting back at the writer boundary
-     *    produces a working setValue for ANY field depth — top-level OR
-     *    nested under groups. This avoids the previous FSC-key navigation
-     *    that broke for grouped fields, where `inputs.key` is DOM-mangled
-     *    (`'user_address_street'`) and `fsc.form[key]` returns undefined.
-     *
-     * The orphan variant fires only when the bag carries no field tree at
-     * all — genuine "rendered outside a field" scenario.
-     */
-    buildActionContext() {
+            }
+        buildActionContext() {
         const inputs = this.fieldInputs();
         const key = inputs?.key ?? '';
         const type = inputs?.type ?? '';
         const tree = inputs?.field;
         if (tree) {
-            // `writeToFieldValue` centralises the `Signal → WritableSignal` cast and
-            // warns at runtime if Signal Forms ever stops storing a writable signal
-            // here (the alternative — a silent no-op preset — is much worse).
-            const setValue = inputs?.setValue ?? ((next) => writeToFieldValue(tree.value, next, this.logger));
+                                                const setValue = inputs?.setValue ?? ((next) => writeToFieldValue(tree.value, next, this.logger));
             return {
                 field: { key, type },
                 form: tree,
@@ -1433,26 +810,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             type: Directive,
             args: [{}]
         }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }] } });
-/** Forwarded onto `NgForgeAddonActionBase` via the `NgForgeAddonAction` wrapper. */
 const NG_FORGE_ADDON_ACTION_INPUTS = ['addon', 'fieldInputs'];
 const _NG_FORGE_ADDON_ACTION_INPUTS_LOCKSTEP = true;
 void _NG_FORGE_ADDON_ACTION_INPUTS_LOCKSTEP;
-/**
- * Host wrapper for `NgForgeAddonActionBase`. Consumers compose this directly:
- *
- * ```ts
- * \@Component({
- *   hostDirectives: [NgForgeAddonAction],
- *   template: `
- *     <p-button [loading]="action.loading()" [disabled]="action.disabled()"
- *               (onClick)="action.dispatch()" />
- *   `,
- * })
- * export class MyButtonAddon {
- *   protected readonly action = injectNgForgeAddonAction<MyButtonAddon>();
- * }
- * ```
- */
 class NgForgeAddonAction {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgForgeAddonAction, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.14", type: NgForgeAddonAction, isStandalone: true, hostDirectives: [{ directive: NgForgeAddonActionBase, inputs: ["addon", "addon", "fieldInputs", "fieldInputs"] }], ngImport: i0 });
@@ -1467,40 +827,6 @@ function injectNgForgeAddonAction() {
     return inject(NgForgeAddonActionBase);
 }
 
-/**
- * Marker directive applied to the canonical control element of an
- * `NgForgeField`-using component. Forwards the field's `meta` AND
- * parent-derived aria signals (`aria-invalid`, `aria-required`,
- * `aria-describedby`) onto a target element.
- *
- * By default attributes land on the directive's own host. For wrapped
- * controls (e.g. `<mat-checkbox>`, `<p-toggleSwitch>`) where the canonical
- * native input is rendered as a descendant inside the wrapper, pass a CSS
- * selector through the input alias — the directive caches the resolved
- * descendant set and re-resolves only when the selector changes.
- *
- * @example Bare native control
- * ```html
- * <input ngForgeControl [formField]="ngf.field()" />
- * ```
- *
- * @example Wrapped control with inner native input
- * ```html
- * <mat-checkbox ngForgeControl="input[type='checkbox']" [formField]="ngf.field()">
- *   {{ ngf.label() }}
- * </mat-checkbox>
- * ```
- *
- * @example Dynamic option list (radios rendered in @for)
- * ```html
- * @for (option of options(); track option.value) {
- *   <input type="radio" ngForgeControl [value]="option.value" />
- * }
- * ```
- *
- * Each `@for` iteration creates its own directive instance; Angular's
- * structural lifecycle handles add/remove naturally.
- */
 class NgForgeControl {
     target = input(undefined, { ...(ngDevMode ? { debugName: "target" } : /* istanbul ignore next */ {}), alias: 'ngForgeControl' });
     constructor() {
@@ -1515,31 +841,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             type: Directive,
             args: [{ selector: '[ngForgeControl]' }]
         }], ctorParameters: () => [], propDecorators: { target: [{ type: i0.Input, args: [{ isSignal: true, alias: "ngForgeControl", required: false }] }] } });
-/**
- * Selectorless companion directive for shadow-DOM-encapsulated components
- * (PrimeNG `p-select`, Ionic web components, etc.) where no light-DOM child
- * is the canonical control. Added to the component's `hostDirectives` so the
- * field's `meta` + parent aria land on the component's own host element.
- *
- * For split parent/control components (e.g. `df-prime-select` rendering
- * `df-prime-select-control` internally), place `NgForgeHostControl` on the
- * INNER control component's `hostDirectives` — the inner element is the
- * canonical control, and the marker's `inject(NgForgeField)` walks up the
- * element-injector tree to find the parent's directive instance.
- *
- * @example
- * ```ts
- * \@Component({
- *   hostDirectives: [
- *     { directive: NgForgeField, inputs: [...NG_FORGE_FIELD_INPUTS] },
- *     NgForgeHostControl,
- *   ],
- *   template: `...`,
- * })
- * export class IonicInputField { ... }
- * ```
- */
-// Empty `@Directive({})` is intentional — selectorless; used only via `hostDirectives`.
 class NgForgeHostControl {
     constructor() {
         const parent = inject(NgForgeField);
@@ -1554,32 +855,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             args: [{}]
         }], ctorParameters: () => [] });
 
-/**
- * Value-bearing field host wrapper. Composes `NgForgeFieldShell` (universal
- * identity) with `NgForgeField` (value + validation + aria + meta-tracking)
- * in a single host-directive entry, so consumer components compose just one
- * directive instead of two.
- *
- * Why a directive instead of a `const` preset: cross-package partial
- * compilation can't resolve a const reference inside `hostDirectives:`, so
- * an exported const array doesn't work for library consumers. A wrapper
- * directive's own `hostDirectives` IS a literal at compile time (in this
- * file), so it works everywhere.
- *
- * Authoring shape for adapter components:
- * ```ts
- * \@Component({
- *   hostDirectives: [NgForgeFieldHost],
- *   ...
- * })
- * export class MyInputField {
- *   protected readonly ngf = injectNgForgeField<string>();
- * }
- * ```
- *
- * Pattern reference: Taiga UI uses the same wrapper-directive technique
- * for the same reason. See https://www.angularspace.com/host-directives-decomposition-unleashed/
- */
 class NgForgeFieldHost {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgForgeFieldHost, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.14", type: NgForgeFieldHost, isStandalone: true, hostDirectives: [{ directive: NgForgeFieldShell, inputs: ["key", "key", "className", "className"] }, { directive: NgForgeField, inputs: ["field", "field", "label", "label", "placeholder", "placeholder", "tabIndex", "tabIndex", "props", "props", "meta", "meta", "validationMessages", "validationMessages"] }], ngImport: i0 });
@@ -1593,22 +868,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     ],
                 }]
         }] });
-/**
- * Action / button host wrapper. Composes `NgForgeFieldShell` with
- * `NgForgeAction` (event dispatch + aria-disabled) for button-shaped
- * components.
- *
- * Authoring shape:
- * ```ts
- * \@Component({
- *   hostDirectives: [NgForgeActionHost],
- *   ...
- * })
- * export class MyButton {
- *   protected readonly action = injectNgForgeAction();
- * }
- * ```
- */
 class NgForgeActionHost {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: NgForgeActionHost, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.14", type: NgForgeActionHost, isStandalone: true, hostDirectives: [{ directive: NgForgeFieldShell, inputs: ["key", "key", "className", "className"] }, { directive: NgForgeAction, inputs: ["label", "label", "disabled", "disabled", "hidden", "hidden", "tabIndex", "tabIndex", "event", "event", "eventArgs", "eventArgs", "eventContext", "eventContext", "props", "props"] }], ngImport: i0 });
@@ -1623,14 +882,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                 }]
         }] });
 
-/**
- * Builds a `ComponentFixture` for an `NgForgeField`-composing component with
- * `field` + `key` bound BEFORE `detectChanges()` — sidesteps the NG0950 that
- * Shell's required `key` and Field's required `field` would otherwise throw.
- *
- * The caller drives `detectChanges()` themselves (so they can `setInput`
- * additional component-specific props in between).
- */
 function createNgForgeFieldFixture(component, options) {
     TestBed.configureTestingModule({ imports: [component], providers: [...(options.providers ?? [])] });
     const key = options.key;
@@ -1657,11 +908,6 @@ function createNgForgeFieldFixture(component, options) {
     }
     return { fixture, field, rootValue };
 }
-/**
- * Builds a `ComponentFixture` for an `NgForgeAction`-composing component with
- * `key` + `label` bound and `EventBus` provided. The caller calls
- * `detectChanges()`; the harness handles the NG0950-avoidance bindings.
- */
 function createNgForgeActionFixture(component, options) {
     TestBed.configureTestingModule({ imports: [component], providers: [EventBus, ...(options.providers ?? [])] });
     const fixture = TestBed.createComponent(component);
@@ -1682,29 +928,11 @@ function createNgForgeActionFixture(component, options) {
     }
     return { fixture, eventBus: TestBed.inject(EventBus) };
 }
-/** Provider for `DEFAULT_VALIDATION_MESSAGES` in field tests — supply the default-messages map and the directive resolves it from DI. */
 function provideTestValidationMessages(messages) {
     return { provide: DEFAULT_VALIDATION_MESSAGES, useValue: signal(messages) };
 }
 
-/**
- * @ng-forge/dynamic-forms/integration
- *
- * Integration API for UI library authors building field implementations
- * (Material, Bootstrap, PrimeNG, Ionic, etc.)
- *
- * This entrypoint provides:
- * - Specific field type definitions (InputField, SelectField, etc.)
- * - Field mappers for creating FieldTypeDefinition
- * - Error display utilities for field components
- */
-// =============================================================================
-// Field Mappers
-// =============================================================================
 
-/**
- * Generated bundle index. Do not edit.
- */
 
 export { ADDON_PRESET_HANDLER, NG_FORGE_ACTION_INPUTS, NG_FORGE_ADDONS_INPUTS, NG_FORGE_ADDON_ACTION_INPUTS, NG_FORGE_FIELD_SHELL_INPUTS, NG_FORGE_VALUE_FIELD_INPUTS, NgForgeAction, NgForgeActionHost, NgForgeAddonAction, NgForgeAddonActionBase, NgForgeAddons, NgForgeAddonsBase, NgForgeControl, NgForgeField, NgForgeFieldHost, NgForgeFieldShell, NgForgeHostControl, addArrayItemButtonMapper, buildArrayButtonEventContext, buildValueFieldInputs, buttonFieldMapper, checkboxFieldMapper, createAriaDescribedBySignal, createNgForgeActionFixture, createNgForgeFieldFixture, createResolvedErrorsSignal, datepickerFieldMapper, injectNgForgeAction, injectNgForgeAddonAction, injectNgForgeAddons, injectNgForgeField, insertArrayItemButtonMapper, nextButtonFieldMapper, optionsFieldMapper, popArrayItemButtonMapper, prependArrayItemButtonMapper, previousButtonFieldMapper, provideTestValidationMessages, removeArrayItemButtonMapper, resolveArrayButtonContext, resolveArrayButtonEventArgs, resolveValueFieldContext, setupMetaTracking, shiftArrayItemButtonMapper, shouldShowErrors, submitButtonFieldMapper, valueFieldMapper };
 //# sourceMappingURL=ng-forge-dynamic-forms-integration.mjs.map