@ng-forge/dynamic-forms 0.1.3 → 0.3.0

package/types/ng-forge-dynamic-forms.d.ts

@@ -17,6 +17,39 @@ type Prettify<T> = {
 
 type DynamicText = string | Observable<string> | Signal<string>;
 
+/**
+ * Base interface for native HTML attributes that can be passed to form field elements.
+ *
+ * This interface serves as the base type for all meta attributes. Specific field types
+ * (like input, textarea) extend this with their own specialized meta types.
+ *
+ * @example
+ * ```typescript
+ * // Using FieldMeta for custom attributes
+ * meta: {
+ *   'data-testid': 'email-input',
+ *   'aria-describedby': 'email-help',
+ *   'x-custom': 'value'
+ * }
+ * ```
+ *
+ * @public
+ */
+interface FieldMeta {
+    /**
+     * Allows any data-* attribute
+     */
+    [key: `data-${string}`]: string | undefined;
+    /**
+     * Allows any aria-* attribute
+     */
+    [key: `aria-${string}`]: string | boolean | undefined;
+    /**
+     * Allows additional custom attributes as escape hatch
+     */
+    [key: string]: string | number | boolean | undefined;
+}
+
 /**
  * Base interface for all dynamic form field definitions.
  *
@@ -56,10 +89,11 @@ type DynamicText = string | Observable<string> | Signal<string>;
  * ```
  *
  * @typeParam TProps - Field-specific properties interface
+ * @typeParam TMeta - Native HTML attributes interface (extends FieldMeta)
  *
  * @public
  */
-interface FieldDef<TProps> {
+interface FieldDef<TProps, TMeta extends FieldMeta = FieldMeta> {
     /**
      * Unique field identifier used for form binding and value tracking.
      *
@@ -136,6 +170,32 @@ interface FieldDef<TProps> {
      * ```
      */
     props?: TProps;
+    /**
+     * Native HTML attributes to pass through to the underlying element.
+     *
+     * Contains attributes that are applied directly to the native input/element.
+     * Useful for accessibility, autocomplete hints, and custom attributes.
+     * The shape is defined by the TMeta generic parameter, which extends FieldMeta.
+     *
+     * @example
+     * ```typescript
+     * // Input field meta
+     * meta: {
+     *   autocomplete: 'email',
+     *   inputmode: 'email',
+     *   'aria-describedby': 'email-help',
+     *   'data-testid': 'email-input'
+     * }
+     *
+     * // Textarea meta
+     * meta: {
+     *   wrap: 'soft',
+     *   spellcheck: true,
+     *   'aria-label': 'Description field'
+     * }
+     * ```
+     */
+    meta?: TMeta;
     /**
      * Additional CSS classes for custom styling.
      *
@@ -236,7 +296,7 @@ type IncludedKeys = 'label' | 'className' | 'hidden' | 'tabIndex';
  *
  * @public
  */
-type FieldComponent<T extends FieldDef<any>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
+type FieldComponent<T extends FieldDef<unknown, FieldMeta>> = Prettify<WithInputSignals<Pick<T, IncludedKeys>>>;
 
 /**
  * Re-export Angular's ValidationError for consistency
@@ -261,8 +321,10 @@ interface ValidationMessages {
  * This is a programmatic field type only - users cannot customize this field type
  *
  * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
- * For documentation: Rows should contain groups and leaf fields, but NOT pages or other rows.
+ * For documentation: Rows should contain groups and leaf fields, but NOT pages, other rows, or hidden fields.
  * Runtime validation enforces these rules.
+ *
+ * Note: Rows are container fields and do not support `meta` since they have no native form element.
  */
 interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowAllowedChildren[]> extends FieldDef<never> {
     type: 'row';
@@ -270,6 +332,8 @@ interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowA
     readonly fields: TFields;
     /** Row fields do not have a label property **/
     readonly label?: never;
+    /** Rows do not support meta - they have no native form element **/
+    readonly meta?: never;
 }
 /**
  * Type guard for RowField with proper type narrowing
@@ -284,18 +348,74 @@ declare function isRowField(field: FieldDef<any>): field is RowField;
  * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
  * For documentation: Groups should contain rows and leaf fields, but NOT pages or other groups.
  * Runtime validation enforces these rules.
+ *
+ * Note: Groups are container fields and do not support `meta` since they have no native form element.
  */
 interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly GroupAllowedChildren[]> extends FieldDef<never> {
     type: 'group';
     readonly fields: TFields;
     /** Groups do not have a label property - they are logical containers only **/
     readonly label?: never;
+    /** Groups do not support meta - they have no native form element **/
+    readonly meta?: never;
 }
 /**
  * Type guard for GroupField with proper type narrowing
  */
 declare function isGroupField(field: FieldDef<any>): field is GroupField;
 
+/**
+ * Scalar types supported by hidden fields.
+ * These are the primitive value types that can be stored.
+ */
+type HiddenScalar = string | number | boolean;
+/**
+ * All value types supported by hidden fields.
+ * Supports both scalar values and arrays of scalars for storing
+ * multiple IDs or similar data.
+ */
+type HiddenValue = HiddenScalar | HiddenScalar[];
+/**
+ * Hidden field definition for storing values without rendering UI.
+ *
+ * Hidden fields participate in the form schema and contribute to form values,
+ * but do not render any visible component. They are useful for:
+ * - Storing IDs when updating existing records
+ * - Persisting metadata that shouldn't be user-editable
+ * - Tracking computed values that need to be submitted
+ *
+ * Unlike the `hidden` property on other fields (which hides a rendered field),
+ * this field type renders nothing at all - it's a componentless field.
+ *
+ * @example
+ * ```typescript
+ * // Store a record ID for updates
+ * const idField: HiddenField<string> = {
+ *   type: 'hidden',
+ *   key: 'id',
+ *   value: '550e8400-e29b-41d4-a716-446655440000',
+ * };
+ *
+ * // Store multiple tag IDs
+ * const tagIdsField: HiddenField<number[]> = {
+ *   type: 'hidden',
+ *   key: 'tagIds',
+ *   value: [1, 2, 3],
+ * };
+ * ```
+ *
+ * @typeParam TValue - The type of value stored (must be HiddenValue compatible)
+ */
+interface HiddenField<TValue extends HiddenValue = HiddenValue> extends FieldDef<never> {
+    /** Discriminant for hidden field type */
+    type: 'hidden';
+    /**
+     * The value to store in the form.
+     * This is required - a hidden field without a value serves no purpose.
+     */
+    value: TValue;
+}
+
 /**
  * Type constraints for field nesting rules
  * These ensure that container fields can only contain valid child field types
@@ -309,9 +429,10 @@ declare function isGroupField(field: FieldDef<any>): field is GroupField;
 type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField;
 /**
  * Fields that are allowed as children of Row fields
- * Rows can contain: groups, arrays, and leaf fields (but NOT pages or other rows)
+ * Rows can contain: groups, arrays, and leaf fields (but NOT pages, other rows, or hidden fields)
+ * Hidden fields are excluded because rows are for horizontal layouts and hidden fields don't render
  */
-type RowAllowedChildren = LeafFieldTypes | GroupField | ArrayField;
+type RowAllowedChildren = Exclude<LeafFieldTypes, HiddenField> | GroupField | ArrayField;
 /**
  * Fields that are allowed as children of Group fields
  * Groups can contain: rows and leaf fields (but NOT pages or other groups)
@@ -359,6 +480,8 @@ type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField;
  *
  * Nesting constraints: Arrays can contain rows, leaf fields, or groups (for object arrays),
  * but NOT pages or other arrays. Runtime validation enforces these rules.
+ *
+ * Note: Arrays are container fields and do not support `meta` since they have no native form element.
  */
 interface ArrayField<TFields extends readonly ArrayAllowedChildren[] = readonly ArrayAllowedChildren[]> extends FieldDef<never> {
     type: 'array';
@@ -371,6 +494,8 @@ interface ArrayField<TFields extends readonly ArrayAllowedChildren[] = readonly
     readonly fields: TFields;
     /** Array fields do not have a label property **/
     readonly label?: never;
+    /** Arrays do not support meta - they have no native form element **/
+    readonly meta?: never;
 }
 /**
  * Type guard for ArrayField with proper type narrowing
@@ -416,6 +541,8 @@ interface PageLogicConfig {
  * TypeScript cannot enforce field nesting rules due to circular dependency limitations.
  * For documentation: Pages should contain rows, groups, and leaf fields, but NOT other pages.
  * Runtime validation enforces these rules.
+ *
+ * Note: Pages are container fields and do not support `meta` since they have no native form element.
  */
 interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowedChildren[]> extends FieldDef<never> {
     type: 'page';
@@ -423,6 +550,8 @@ interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowed
     readonly fields: TFields;
     /** Page fields do not have a label property **/
     readonly label?: never;
+    /** Pages do not support meta - they have no native form element **/
+    readonly meta?: never;
     /**
      * Logic configurations for conditional page visibility.
      * Only 'hidden' type logic is supported for pages.
@@ -618,6 +747,7 @@ interface FieldRegistryContainers {
  */
 interface FieldRegistryLeaves {
     text: TextField;
+    hidden: HiddenField;
 }
 /**
  * Global interface for dynamic form field definitions with categorization
@@ -707,10 +837,10 @@ type NarrowField<T> = T extends {
 type NarrowFields = readonly NarrowField<RegisteredFieldTypes>[];
 
 /**
- * Helper type to convert union to intersection
- * Note: `any` is necessary for distributive conditional types
+ * Helper type to convert union to intersection.
+ * Uses `U extends U` to trigger distributive conditional type behavior.
  */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type UnionToIntersection<U> = (U extends U ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
  * Depth counter for recursion limiting (prevents infinite type instantiation)
  */
@@ -928,8 +1058,8 @@ interface SchemaDefinition {
  * - Field state: `ctx.state` (errors, touched, dirty, etc.)
  * - Other field values: `ctx.valueOf(path)` where path is a FieldPath
  * - Other field states: `ctx.stateOf(path)`
- * - Other fields: `ctx.fieldOf(path)`
- * - Current field tree: `ctx.field`
+ * - Other fields: `ctx.fieldTreeOf(path)`
+ * - Current field tree: `ctx.fieldTree`
  *
  * **Return Types:**
  * - Single error: `{ kind: 'errorKind' }` for field-level validation
@@ -1184,7 +1314,7 @@ interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
  * Interface for dynamic forms logger implementations.
  * Allows custom logging integrations (Sentry, DataDog, etc.)
  */
-interface DynamicFormLogger {
+interface Logger {
     /**
      * Log a debug message.
      * Use for detailed diagnostic information during development.
@@ -1217,7 +1347,7 @@ interface EvaluationContext<TValue = unknown> {
     /** Custom evaluation functions */
     customFunctions?: Record<string, (context: EvaluationContext) => unknown>;
     /** Logger for diagnostic output */
-    logger: DynamicFormLogger;
+    logger: Logger;
     /** Allow additional properties for flexible expression evaluation */
     [key: string]: unknown;
 }
@@ -1956,12 +2086,45 @@ interface FieldTypeDefinition<T extends FieldDef<any> = any> {
     name: string;
     /** Field definition type marker (internal use) */
     _fieldDef?: T;
-    /** Function to load the component (supports lazy loading) */
+    /**
+     * Function to load the component (supports lazy loading).
+     * Returns a Promise that resolves to the component class or module with default export.
+     *
+     * Optional - omit for componentless fields (e.g., hidden fields) that only
+     * contribute to form values without rendering any UI.
+     */
     loadComponent?: () => Promise<any>;
-    /** Mapper function that converts field definition to component bindings */
-    mapper: MapperFn<T>;
+    /**
+     * Mapper function that converts field definition to component bindings.
+     *
+     * Optional - omit for componentless fields (like hidden fields) that don't need
+     * input mapping. When omitted for componentless fields (no loadComponent), an empty
+     * signal is returned. When omitted for regular fields with a component, falls back
+     * to baseFieldMapper.
+     */
+    mapper?: MapperFn<T>;
     /** How this field type handles form values and data collection (defaults to 'include') */
     valueHandling?: ValueHandlingMode;
+    /**
+     * List of prop keys to forward to the meta object.
+     *
+     * Some props (like `type` for inputs, `rows`/`cols` for textareas) are actually
+     * native HTML attributes. Specifying them here causes them to be merged into
+     * the meta object before being passed to the component, ensuring they're applied
+     * via the meta tracking mechanism.
+     *
+     * Note: Meta values always take precedence over forwarded props.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   name: 'input',
+     *   propsToMeta: ['type'],
+     *   // ...
+     * }
+     * ```
+     */
+    propsToMeta?: string[];
 }
 /**
  * Injection token for the global field type registry.
@@ -2330,9 +2493,11 @@ type ExtractFieldDef<T> = T extends FieldTypeDefinition<infer F> ? F : never;
 type FieldDefUnion<T extends FieldTypeDefinition[]> = ExtractFieldDef<T[number]>;
 /**
  * Infer form value type from field definitions
+ * Note: Full value type inference requires complex recursive type mapping.
+ * Using unknown as placeholder until full inference is implemented.
  */
-type InferFormValue<TFieldDefs extends FieldDef<any>[]> = {
-    [K in TFieldDefs[number]['key']]: any;
+type InferFormValue<TFieldDefs extends FieldDef<unknown>[]> = {
+    [K in TFieldDefs[number]['key']]: unknown;
 };
 /**
  * Provider result with type inference
@@ -2357,7 +2522,7 @@ type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
  * This function creates environment providers that can be used at application or route level
  * to register field types. It provides type-safe field registration with automatic type inference.
  *
- * @param items - Field type definitions and/or features (like withLogger)
+ * @param items - Field type definitions and/or features (like withLoggerConfig)
  * @returns Environment providers for dependency injection with type inference
  *
  * @example
@@ -2372,12 +2537,12 @@ type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
  *
  * @example
  * ```typescript
- * // With logging configuration
+ * // Disable logging
  * bootstrapApplication(AppComponent, {
  *   providers: [
  *     provideDynamicForm(
  *       ...withMaterialFields(),
- *       withLogger({ level: LogLevel.Debug })
+ *       withLoggerConfig(false)
  *     )
  *   ]
  * });
@@ -2385,18 +2550,6 @@ type ExtractFieldTypes<T extends FieldTypeOrFeature[]> = {
  *
  * @example
  * ```typescript
- * // Route-level setup
- * const routes: Routes = [
- *   {
- *     path: 'form',
- *     component: FormComponent,
- *     providers: [provideDynamicForm(...withMaterialFields())]
- *   }
- * ];
- * ```
- *
- * @example
- * ```typescript
  * // Custom field types with type inference
  * import { CustomFieldType, AnotherFieldType } from './custom-fields';
  *
@@ -2456,93 +2609,65 @@ type ExtractFormValue<T> = T extends {
  * { type: 'page', key: 'step1', fields: [...] }
  * ```
  */
-declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
-
 /**
- * Log levels for the dynamic forms logger.
- * Each level includes all levels above it (more severe).
+ * Built-in field types provided by the dynamic form library.
  *
- * - Off: No logging
- * - Error: Only errors
- * - Warn: Errors + warnings
- * - Info: Errors + warnings + info
- * - Debug: All messages including debug
+ * Each field type is validated at compile time using satisfies, ensuring
+ * type safety of the mapper function while allowing the array to be typed
+ * as FieldTypeDefinition[] for consumer flexibility.
  */
-declare enum LogLevel {
-    /** Disable all logging */
-    Off = 0,
-    /** Only log errors */
-    Error = 1,
-    /** Log errors and warnings */
-    Warn = 2,
-    /** Log errors, warnings, and info messages */
-    Info = 3,
-    /** Log all messages including debug */
-    Debug = 4
-}
+declare const BUILT_IN_FIELDS: FieldTypeDefinition[];
 
-/**
- * Configuration options for the logger feature
- */
-interface LoggerFeatureOptions {
-    /**
-     * Log level to use. Messages below this level will be filtered.
-     * @default LogLevel.Warn in dev, LogLevel.Off in prod
-     */
-    level?: LogLevel;
-    /**
-     * Custom logger implementation.
-     * Use this to integrate with external logging services (Sentry, DataDog, etc.)
-     * If provided, `level` is ignored - your implementation controls filtering.
-     */
-    logger?: DynamicFormLogger;
-}
 /**
  * Configure logging for dynamic forms.
  *
+ * By default, logging is enabled (ConsoleLogger). Use this feature to disable logging
+ * or configure it conditionally.
+ *
  * @example
  * ```typescript
- * // Set log level
+ * // Disable logging
  * provideDynamicForm(
  *   ...withMaterialFields(),
- *   withLogger({ level: LogLevel.Debug })
+ *   withLoggerConfig(false)
  * )
  *
- * // Disable logging entirely
+ * // Conditional logging (e.g., only in dev mode)
  * provideDynamicForm(
  *   ...withMaterialFields(),
- *   withLogger({ level: LogLevel.Off })
- * )
- *
- * // Custom logger implementation
- * provideDynamicForm(
- *   ...withMaterialFields(),
- *   withLogger({ logger: mySentryLogger })
+ *   withLoggerConfig(() => isDevMode())
  * )
  * ```
  *
- * @param options - Logger configuration options
+ * @param enabled - Whether logging is enabled. Can be a boolean or a function that returns a boolean. Defaults to true.
  * @returns A DynamicFormFeature that configures logging
  */
-declare function withLogger(options?: LoggerFeatureOptions): DynamicFormFeature<'logger'>;
+declare function withLoggerConfig(enabled?: boolean | (() => boolean)): DynamicFormFeature<'logger'>;
 
 /**
  * Injection token for the dynamic forms logger.
  *
- * Default behavior:
- * - Development mode: ConsoleLogger with LogLevel.Warn
- * - Production mode: NoopLogger (silent)
- *
- * Override by providing a custom logger via withLogger() feature
- * or by providing directly to this token.
+ * Provided by provideDynamicForm() with ConsoleLogger as default.
+ * Override with withLoggerConfig(false) to disable logging.
  */
-declare const DYNAMIC_FORM_LOGGER: InjectionToken<DynamicFormLogger>;
+declare const DynamicFormLogger: InjectionToken<Logger>;
+
+/**
+ * Console-based logger implementation.
+ */
+declare class ConsoleLogger implements Logger {
+    private readonly prefix;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
 
 /**
  * No-operation logger implementation.
  * All methods are no-ops - used in production by default.
  */
-declare class NoopLogger implements DynamicFormLogger {
+declare class NoopLogger implements Logger {
     debug(): void;
     info(): void;
     warn(): void;
@@ -2626,7 +2751,7 @@ interface ButtonLogicContext {
     /** Current form value for evaluating conditional expressions */
     formValue?: unknown;
     /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
-    logger?: DynamicFormLogger;
+    logger?: Logger;
 }
 /**
  * Resolves the disabled state for a submit button.
@@ -2700,7 +2825,7 @@ interface FieldWithValidation {
  * This type represents all possible value types that can be used in form fields.
  */
 type ValueType = string | number | boolean | Date | object | unknown[];
-interface BaseValueField<TProps, TValue> extends FieldDef<TProps>, FieldWithValidation {
+interface BaseValueField<TProps, TValue, TMeta extends FieldMeta = FieldMeta> extends FieldDef<TProps, TMeta>, FieldWithValidation {
     value?: TValue;
     /**
      * Placeholder text displayed when the field is empty.
@@ -2709,11 +2834,11 @@ interface BaseValueField<TProps, TValue> extends FieldDef<TProps>, FieldWithVali
     placeholder?: DynamicText;
     required?: boolean;
 }
-declare function isValueField<TProps>(field: FieldDef<TProps>): field is BaseValueField<TProps, ValueType>;
+declare function isValueField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseValueField<TProps, ValueType, TMeta>;
 type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'valueType' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'schemas';
-type ValueFieldComponent<T extends BaseValueField<any, unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
+type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
 
-interface BaseCheckedField<TProps> extends FieldDef<TProps>, FieldWithValidation {
+interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta> extends FieldDef<TProps, TMeta>, FieldWithValidation {
     value?: boolean;
     /**
      * Placeholder text displayed when the field is empty.
@@ -2722,9 +2847,9 @@ interface BaseCheckedField<TProps> extends FieldDef<TProps>, FieldWithValidation
     placeholder?: DynamicText;
     required?: boolean;
 }
-declare function isCheckedField<TProps>(field: FieldDef<TProps>): field is BaseCheckedField<TProps>;
+declare function isCheckedField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseCheckedField<TProps, TMeta>;
 type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation;
-type CheckedFieldComponent<T extends BaseCheckedField<any>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
+type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
 
 declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
 declare function applyValidators(configs: ValidatorConfig[], fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
@@ -2865,7 +2990,7 @@ declare class EventBus {
      * eventBus.dispatch(CustomFormEvent);
      * ```
      */
-    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: any[]): void;
+    dispatch<T extends FormEventConstructor>(eventConstructor: T, ...args: ConstructorParameters<T>): void;
     /**
      * Subscribes to events of a specific type.
      *
@@ -2935,6 +3060,18 @@ interface ArrayItemContext {
     formValue?: unknown;
 }
 
+/**
+ * Base error class for all Dynamic Forms errors.
+ *
+ * This class centralizes the `[Dynamic Forms]` prefix, ensuring consistent
+ * error messaging across the library without requiring each error site to
+ * manually include the prefix.
+ */
+declare class DynamicFormError extends Error {
+    private static readonly PREFIX;
+    constructor(message: string);
+}
+
 /**
  * Builds base input properties from a field definition.
  *
@@ -3024,6 +3161,33 @@ declare function textFieldMapper(fieldDef: TextField): Signal<Record<string, unk
  */
 declare function dynamicTextToObservable(value: DynamicText | undefined, injector?: Injector): Observable<string>;
 
+/**
+ * Applies meta attributes to a DOM element and tracks which attributes were applied.
+ *
+ * This utility handles:
+ * - Removing previously applied attributes that are no longer in meta
+ * - Setting new attributes from meta
+ * - Converting all values to strings via String()
+ *
+ * @param element - The DOM element to apply attributes to
+ * @param meta - The meta object containing attributes to apply
+ * @param previouslyApplied - Set of attribute names that were previously applied
+ * @returns A new Set containing the attribute names that were applied
+ *
+ * @example
+ * ```typescript
+ * private appliedAttrs = new Set<string>();
+ *
+ * explicitEffect([this.meta], ([meta]) => {
+ *   const input = this.el.nativeElement.querySelector('input');
+ *   if (input) {
+ *     this.appliedAttrs = applyMetaToElement(input, meta, this.appliedAttrs);
+ *   }
+ * });
+ * ```
+ */
+declare function applyMetaToElement(element: Element, meta: FieldMeta | undefined, previouslyApplied: Set<string>): Set<string>;
+
 /**
  * Pipe that handles dynamic text resolution with support for static strings,
  * Observables, and Signals.
@@ -3226,5 +3390,5 @@ declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): O
  */
 declare function interpolateParams(message: string, error: ValidationError): string;
 
-export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, DYNAMIC_FORM_LOGGER, DynamicForm, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, LogLevel, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RowFieldComponent, SubmitEvent, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, dynamicTextToObservable, getArrayLength, groupFieldMapper, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withLogger };
-export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, DynamicFormLogger, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, LoggerFeatureOptions, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };
+export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FormClearEvent, FormResetEvent, GroupFieldComponent, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RowFieldComponent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, dynamicTextToObservable, getArrayLength, groupFieldMapper, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withLoggerConfig };
+export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };