@ng-forge/dynamic-forms 1.0.0-rc.1 → 1.0.0-rc.3

package/fesm2022/{ng-forge-dynamic-forms-ng-forge-dynamic-forms-DTkMZcnb.mjs → ng-forge-dynamic-forms-ng-forge-dynamic-forms-C59pvc26.mjs}

@@ -1,12 +1,12 @@
 import * as i0 from '@angular/core';
 import { reflectComponentType, Injector, inject, EnvironmentInjector, DestroyRef, computed, signal, input, ViewContainerRef, Directive, linkedSignal, ChangeDetectionStrategy, Component, Injectable, InjectionToken, isSignal, runInInjectionContext, afterNextRender, untracked, PendingTasks, ElementRef, PLATFORM_ID, isDevMode, TemplateRef, model, contentChildren, makeEnvironmentProviders } from '@angular/core';
 import { explicitEffect } from 'ngxtension/explicit-effect';
-import { DynamicFormLogger, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, toReadonlyFieldTreeCached, writeToFieldValue, WRAPPER_AUTO_ASSOCIATIONS, DEFAULT_WRAPPERS, READONLY_FIELD_TREE_CACHE, EventBus, FieldContextRegistryService, FunctionRegistryService, FORM_OPTIONS, evaluateCondition, FIELD_SIGNAL_CONTEXT, isRowField, isContainerField, isArrayField, hasChildFields, isSimplifiedArrayField, DynamicFormError, isStateLogicConfig, isDerivationLogicConfig, createDebouncedLogicFunction, createLogicFunction, ExpressionParser, applyValidator, isPageField, isContainerTypedField, isGroupField, getFieldValueHandling, normalizeFieldsArray, getNestedValue, isCrossFieldValidator, extractStringDependencies, isCrossFieldBuiltInValidator, hasCrossFieldWhenCondition, extractExpressionDependencies, isCrossFieldStateLogic, isCrossFieldSchema, keyBy, mapValues, isEqual, hasTargetProperty, ARRAY_CONTEXT, GROUP_CONTEXT, FORM_ID_PREFIX, baseFieldMapper, detectFormMode, validatePageNesting, FIELD_REGISTRY, assertNever, ADDON_KIND_REGISTRY, deepMergeDefaults, derivedFromDeferred, createWarningTracker, RootFormRegistryService, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, EXTERNAL_DATA, DEPRECATION_WARNING_TRACKER, HttpConditionCache, HTTP_CONDITION_CACHE, HttpConditionFunctionCacheService, AsyncConditionFunctionCacheService, DynamicValueFunctionCacheService, LogicFunctionCacheService, setupInitializationTracking, ComponentInitializedEvent, DF_FIELD_TEMPLATES, rowFieldMapper, groupFieldMapper, arrayFieldMapper, pageFieldMapper, textFieldMapper, containerFieldMapper, isWrapperTypeDefinition, createDefaultDerivationLogConfig, NoopLogger, EMIT_FORM_VALUE_ON_EVENTS, resolveDynamicValue, DynamicTextPipe } from '@ng-forge/dynamic-forms/internal';
+import { DynamicFormLogger, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, toReadonlyFieldTreeCached, writeToFieldValue, WRAPPER_AUTO_ASSOCIATIONS, DEFAULT_WRAPPERS, READONLY_FIELD_TREE_CACHE, EventBus, FieldContextRegistryService, FunctionRegistryService, FORM_OPTIONS, evaluateCondition, FIELD_SIGNAL_CONTEXT, isRowField, isContainerField, isArrayField, hasChildFields, isSimplifiedArrayField, DynamicFormError, isStateLogicConfig, isDerivationLogicConfig, createDebouncedLogicFunction, createLogicFunction, ExpressionParser, applyValidator, isPageField, isGenericContainerField, isGroupField, getFieldValueHandling, normalizeFieldsArray, getNestedValue, isCrossFieldValidator, extractStringDependencies, isCrossFieldBuiltInValidator, hasCrossFieldWhenCondition, extractExpressionDependencies, isCrossFieldStateLogic, isCrossFieldSchema, keyBy, mapValues, isEqual, hasTargetProperty, ARRAY_CONTEXT, GROUP_CONTEXT, FORM_ID_PREFIX, baseFieldMapper, detectFormMode, validatePageNesting, FIELD_REGISTRY, assertNever, ADDON_TYPE_REGISTRY, deepMergeDefaults, derivedFromDeferred, createWarningTracker, RootFormRegistryService, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, EXTERNAL_DATA, DEPRECATION_WARNING_TRACKER, createAddonActionRegistry, ADDON_ACTION_REGISTRY, HttpConditionCache, HTTP_CONDITION_CACHE, HttpConditionFunctionCacheService, AsyncConditionFunctionCacheService, DynamicValueFunctionCacheService, LogicFunctionCacheService, setupInitializationTracking, ComponentInitializedEvent, DF_FIELD_TEMPLATES, rowFieldMapper, groupFieldMapper, arrayFieldMapper, pageFieldMapper, textFieldMapper, containerFieldMapper, isWrapperTypeDefinition, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, createDefaultDerivationLogConfig, NoopLogger, EMIT_FORM_VALUE_ON_EVENTS, DynamicTextPipe, ADDON_ACTION_HANDLERS } from '@ng-forge/dynamic-forms/internal';
 import { takeUntilDestroyed, toObservable, toSignal, outputFromObservable } from '@angular/core/rxjs-interop';
 import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, debounceTime, distinctUntilChanged, tap, pipe, scan, Observable, Subject, concatMap, filter, take } from 'rxjs';
 import { submit, required, disabled, readonly, hidden, applyEach, applyWhenValue, applyWhen, apply, email, minLength, maxLength, pattern, min, max, schema, validateStandardSchema, validateTree, form, provideSignalFormsConfig } from '@angular/forms/signals';
 import { isStandardSchemaMarker } from '@ng-forge/dynamic-forms/schema';
-import { isPlatformBrowser, NgComponentOutlet, AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { isPlatformBrowser, AsyncPipe, NgTemplateOutlet, NgComponentOutlet } from '@angular/common';
 import { NG_STATUS_CLASSES } from '@angular/forms/signals/compat';
 
 const EMPTY_WRAPPERS = Object.freeze([]);
@@ -422,7 +422,7 @@ function createSubmissionHandler(options) {
     }));
 }
 
-class SubmitEvent {
+class FormSubmitEvent {
     type = 'submit';
 }
 
@@ -822,11 +822,11 @@ class PageOrchestratorComponent {
       }
     }
   `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [/* @ts-ignore */
-                import('./ng-forge-dynamic-forms-page-field.component-CjCd5Byo.mjs').then(m => m.default)], () => [/* @ts-ignore */
-                import('./ng-forge-dynamic-forms-page-field.component-CjCd5Byo.mjs').then(m => m.default)]] });
+                import('./ng-forge-dynamic-forms-page-field.component-DRaxbiqA.mjs').then(m => m.default)], () => [/* @ts-ignore */
+                import('./ng-forge-dynamic-forms-page-field.component-DRaxbiqA.mjs').then(m => m.default)]] });
 }
 i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "22.0.0", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [/* @ts-ignore */
-        import('./ng-forge-dynamic-forms-page-field.component-CjCd5Byo.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
+        import('./ng-forge-dynamic-forms-page-field.component-DRaxbiqA.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
                 type: Component,
                 args: [{ selector: 'div[page-orchestrator]', imports: [PageFieldComponent], template: `
     @for (pageField of pageFields(); track pageField.key; let i = $index) {
@@ -1367,7 +1367,7 @@ function getNumberValidationConfig(fieldDef) {
 }
 function mapFieldToForm(fieldDef, fieldPath, inheritedContext = DEFAULT_FIELD_TREE_MAPPING_CONTEXT) {
     const ownContext = resolveFieldOwnContext(fieldDef, inheritedContext);
-                if (isPageField(fieldDef) || isRowField(fieldDef) || isContainerTypedField(fieldDef)) {
+                if (isPageField(fieldDef) || isRowField(fieldDef) || isGenericContainerField(fieldDef)) {
         const descendantContext = resolveDescendantContext(fieldDef, ownContext);
         mapContainerChildren(fieldDef.fields, fieldPath, descendantContext);
         return;
@@ -1389,7 +1389,7 @@ function mapContainerChildren(fields, parentPath, inheritedContext) {
         return;
     const pathRecord = parentPath;
     for (const field of fields) {
-        if (isPageField(field) || isRowField(field) || isContainerTypedField(field)) {
+        if (isPageField(field) || isRowField(field) || isGenericContainerField(field)) {
                                     const layoutOwn = resolveFieldOwnContext(field, inheritedContext);
             const layoutDescendant = resolveDescendantContext(field, layoutOwn);
             mapContainerChildren(field.fields, parentPath, layoutDescendant);
@@ -1510,7 +1510,7 @@ function mapArrayFieldToForm(arrayField, fieldPath, context) {
         }
         else if (isPageField(itemDef) ||
             isRowField(itemDef) ||
-            isContainerTypedField(itemDef)) {
+            isGenericContainerField(itemDef)) {
                                                 collectFieldsFromObjectItem([itemDef], allObjectFields);
         }
         else {
@@ -1526,7 +1526,7 @@ function mapArrayFieldToForm(arrayField, fieldPath, context) {
             const itemSchema = schema((itemPath) => {
         const pathRecord = itemPath;
                 for (const templateField of allObjectFields) {
-            if (isRowField(templateField) || isPageField(templateField) || isContainerTypedField(templateField)) {
+            if (isRowField(templateField) || isPageField(templateField) || isGenericContainerField(templateField)) {
                                 const layoutOwn = resolveFieldOwnContext(templateField, context);
                 const layoutDescendant = resolveDescendantContext(templateField, layoutOwn);
                 mapContainerChildren(templateField.fields, itemPath, layoutDescendant);
@@ -1561,7 +1561,7 @@ function mapArrayFieldToForm(arrayField, fieldPath, context) {
 function collectFieldsFromObjectItem(itemFields, allFields) {
     const seenKeys = new Set(allFields.map((f) => f.key).filter(Boolean));
     for (const field of itemFields) {
-                if (isRowField(field) || isPageField(field) || isContainerTypedField(field)) {
+                if (isRowField(field) || isPageField(field) || isGenericContainerField(field)) {
                         const containerKey = `__container_${field.type}_${JSON.stringify(field.fields?.map((f) => f.key))}`;
             if (!seenKeys.has(containerKey)) {
                 seenKeys.add(containerKey);
@@ -2138,7 +2138,7 @@ function flattenFields(fields, registry, options = {}) {
     let autoKeyCounter = 0;
         for (const field of fields) {
                         const valueHandling = getFieldValueHandling(field.type, registry);
-                                if (options.preserveRows && (isRowField(field) || isContainerTypedField(field))) {
+                                if (options.preserveRows && (isRowField(field) || isGenericContainerField(field))) {
             if (field.fields) {
                                 const flattenedChildren = flattenFields(normalizeFieldsArray(field.fields), registry, options);
                                                 const autoPrefix = isRowField(field) ? 'auto_row' : 'auto_container';
@@ -2801,7 +2801,7 @@ function validateFormConfig(fields, registry, logger) {
     }
 }
 
-function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
+function validateFieldAddons(field, fieldRegistry, typeRegistry, source) {
     const warnings = [];
     const incoming = field.addons;
     if (!incoming?.length) {
@@ -2819,8 +2819,8 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
         return { addons: [], warnings };
     }
     const allowedSlots = addonSupport.slots;
-    const allowedKinds = addonSupport.allowedKinds;
-    const registeredKinds = Array.from(kindRegistry.keys());
+    const allowedTypes = addonSupport.allowedTypes;
+    const registeredTypes = Array.from(typeRegistry.keys());
     const survivors = [];
     for (const addon of incoming) {
                 if (!allowedSlots.includes(addon.slot)) {
@@ -2833,31 +2833,31 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
             });
             continue;
         }
-                        const kindDef = kindRegistry.get(addon.kind);
-        if (!kindDef) {
+                        const typeDef = typeRegistry.get(addon.type);
+        if (!typeDef) {
             warnings.push({
-                type: 'unknown-kind',
+                type: 'unknown-type',
                 fieldKey: field.key,
-                kind: addon.kind,
-                registeredKinds,
+                addonType: addon.type,
+                registeredTypes,
             });
             continue;
         }
-                if (allowedKinds && !allowedKinds.includes(kindDef.kind)) {
+                if (allowedTypes && !allowedTypes.includes(typeDef.type)) {
             warnings.push({
-                type: 'kind-not-allowed',
+                type: 'type-not-allowed',
                 fieldKey: field.key,
                 fieldType,
-                kind: kindDef.kind,
-                allowedKinds,
+                addonType: typeDef.type,
+                allowedTypes,
             });
             continue;
         }
-                        if (source === 'json' && kindDef.jsonSafe === false) {
+                        if (source === 'json' && typeDef.jsonSafe === false) {
             warnings.push({
-                type: 'code-only-kind-in-json',
+                type: 'code-only-type-in-json',
                 fieldKey: field.key,
-                kind: kindDef.kind,
+                addonType: typeDef.type,
             });
             continue;
         }
@@ -2877,7 +2877,7 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
                     warnings.push({
                         type: 'code-only-action-in-json',
                         fieldKey: field.key,
-                        reason: `function '${key}' on kind '${kindDef.kind}' (use a signal/observable in code, or omit in JSON)`,
+                        reason: `function '${key}' on type '${typeDef.type}' (use a signal/observable in code, or omit in JSON)`,
                     });
                 }
             };
@@ -2887,7 +2887,7 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
                 warnings.push({
                     type: 'code-only-action-in-json',
                     fieldKey: field.key,
-                    reason: `inline 'action' function on kind '${kindDef.kind}'`,
+                    reason: `inline 'action' function on type '${typeDef.type}'`,
                 });
             }
             dropReactiveFn('hidden');
@@ -2901,22 +2901,22 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
             warnings.push({
                 type: 'code-only-action-in-json',
                 fieldKey: field.key,
-                reason: `multiple click variants on kind '${kindDef.kind}' (${declaredVariants.join(', ')}); kept '${declaredVariants[0]}'`,
+                reason: `multiple click variants on type '${typeDef.type}' (${declaredVariants.join(', ')}); kept '${declaredVariants[0]}'`,
             });
         }
         if (stripped) {
             survivors.push(sanitized);
             continue;
         }
-                if (kindDef.validate) {
+                if (typeDef.validate) {
             try {
-                kindDef.validate(addon, field.key);
+                typeDef.validate(addon, field.key);
             }
             catch (error) {
                 warnings.push({
                     type: 'shape-violation',
                     fieldKey: field.key,
-                    kind: kindDef.kind,
+                    addonType: typeDef.type,
                     reason: error instanceof Error ? error.message : String(error),
                 });
                 continue;
@@ -2926,18 +2926,18 @@ function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
     }
     return { addons: survivors, warnings };
 }
-function walkAndValidateAddons(fields, fieldRegistry, kindRegistry, source) {
+function walkAndValidateAddons(fields, fieldRegistry, typeRegistry, source) {
     const allWarnings = [];
     const sanitized = fields.map((field) => {
         let next = field;
         if (field.addons?.length) {
-            const { addons, warnings } = validateFieldAddons(field, fieldRegistry, kindRegistry, source);
+            const { addons, warnings } = validateFieldAddons(field, fieldRegistry, typeRegistry, source);
             allWarnings.push(...warnings);
             next = { ...next, addons };
         }
                         const children = next.fields;
         if (Array.isArray(children)) {
-            const { fields: visited, warnings } = walkAndValidateAddons(children, fieldRegistry, kindRegistry, source);
+            const { fields: visited, warnings } = walkAndValidateAddons(children, fieldRegistry, typeRegistry, source);
             allWarnings.push(...warnings);
             next = { ...next, fields: visited };
         }
@@ -2954,14 +2954,14 @@ function addonWarningKey(w) {
             return `${w.type}|${w.fieldKey}|${w.fieldType}`;
         case 'unknown-slot':
             return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.slot}`;
-        case 'unknown-kind':
-            return `${w.type}|${w.fieldKey}|${w.kind}`;
-        case 'kind-not-allowed':
-            return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.kind}`;
+        case 'unknown-type':
+            return `${w.type}|${w.fieldKey}|${w.addonType}`;
+        case 'type-not-allowed':
+            return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.addonType}`;
         case 'shape-violation':
-            return `${w.type}|${w.fieldKey}|${w.kind}|${w.reason}`;
-        case 'code-only-kind-in-json':
-            return `${w.type}|${w.fieldKey}|${w.kind}`;
+            return `${w.type}|${w.fieldKey}|${w.addonType}|${w.reason}`;
+        case 'code-only-type-in-json':
+            return `${w.type}|${w.fieldKey}|${w.addonType}`;
         case 'code-only-action-in-json':
             return `${w.type}|${w.fieldKey}|${w.reason}`;
     }
@@ -2976,17 +2976,17 @@ function formatAddonWarning(w) {
         case 'unknown-slot':
             return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): slot '${w.slot}' is not supported. ` +
                 `Allowed: ${w.allowedSlots.join(', ')}. Addon dropped.`);
-        case 'unknown-kind':
-            return (`Field '${w.fieldKey}': addon kind '${w.kind}' is not registered. ` +
-                `Did you forget withCustomAddon({ kind: '${w.kind}', ... })? ` +
-                `Currently registered: ${w.registeredKinds.join(', ') || '(none)'}. Addon dropped.`);
-        case 'kind-not-allowed':
-            return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): addon kind '${w.kind}' is not in the allowed list. ` +
-                `Allowed: ${w.allowedKinds.join(', ')}. Addon dropped.`);
+        case 'unknown-type':
+            return (`Field '${w.fieldKey}': addon type '${w.addonType}' is not registered. ` +
+                `Did you forget withCustomAddon({ type: '${w.addonType}', ... })? ` +
+                `Currently registered: ${w.registeredTypes.join(', ') || '(none)'}. Addon dropped.`);
+        case 'type-not-allowed':
+            return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): addon type '${w.addonType}' is not in the allowed list. ` +
+                `Allowed: ${w.allowedTypes.join(', ')}. Addon dropped.`);
         case 'shape-violation':
-            return `Field '${w.fieldKey}': addon kind '${w.kind}' shape invalid: ${w.reason}. Addon dropped.`;
-        case 'code-only-kind-in-json':
-            return `Field '${w.fieldKey}': addon kind '${w.kind}' is code-only and cannot be used with JSON-derived configs. Addon dropped.`;
+            return `Field '${w.fieldKey}': addon type '${w.addonType}' shape invalid: ${w.reason}. Addon dropped.`;
+        case 'code-only-type-in-json':
+            return `Field '${w.fieldKey}': addon type '${w.addonType}' is code-only and cannot be used with JSON-derived configs. Addon dropped.`;
         case 'code-only-action-in-json':
             return `Field '${w.fieldKey}': ${w.reason}. Use 'preset' or 'actionRef' instead. Addon dropped.`;
     }
@@ -3537,7 +3537,7 @@ class FormStateManager {
     })();
         valueExclusionDefaults = inject(VALUE_EXCLUSION_DEFAULTS);
         fieldRegistry = injectFieldRegistry();
-        addonKindRegistry = inject(ADDON_KIND_REGISTRY);
+        addonKindRegistry = inject(ADDON_TYPE_REGISTRY);
         lastAddonWarningKeys = new Set();
                 scheduler = createSideEffectScheduler(this.injector);
     machine;
@@ -3944,7 +3944,7 @@ class FormStateManager {
         this.deps.value.set(emptyValue);
     }
         submit() {
-        this.eventBus.dispatch(SubmitEvent);
+        this.eventBus.dispatch(FormSubmitEvent);
     }
                 setupEffects() {
         explicitEffect([this.deps.config], ([config]) => {
@@ -4172,7 +4172,7 @@ function createDerivationRenderGate() {
         if (!has || engine() !== 'idle')
             return;
         engine.set('loading');
-                pendingTasks.run(() => import('./ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-QJzwEYSj.mjs')
+                pendingTasks.run(() => import('./ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-D6ntLtW9.mjs')
             .then(({ bootstrapDerivationOrchestrator }) => {
             runInInjectionContext(injector, () => bootstrapDerivationOrchestrator());
             engine.set('wired');
@@ -4288,19 +4288,6 @@ const DERIVATION_WARNING_TRACKER = new InjectionToken('DerivationWarningTracker'
     factory: createWarningTracker,
 });
 
-const ADDON_ACTION_HANDLERS = new InjectionToken('ADDON_ACTION_HANDLERS');
-const ADDON_ACTION_REGISTRY = new InjectionToken('ADDON_ACTION_REGISTRY');
-function createAddonActionRegistry() {
-    const sources = inject(ADDON_ACTION_HANDLERS, { optional: true }) ?? [];
-    const map = new Map();
-    for (const handlers of sources) {
-        for (const [name, fn] of Object.entries(handlers)) {
-            map.set(name, fn);
-        }
-    }
-    return map;
-}
-
 function coreProviders() {
     return [
         EventBus,
@@ -4504,7 +4491,7 @@ class DynamicForm {
     }
         onNativeSubmit(event) {
         event.preventDefault();
-        this.eventBus.dispatch(SubmitEvent);
+        this.eventBus.dispatch(FormSubmitEvent);
     }
                 setupEffects() {
                 explicitEffect([this.formModeDetection, this.pageFieldDefinitions], ([{ mode }, pages]) => {
@@ -4638,87 +4625,38 @@ function countContainersRecursive(fields) {
     return count;
 }
 
-const ADDON_KIND_COMPONENT_CACHE = new InjectionToken('ADDON_KIND_COMPONENT_CACHE');
-function injectAddonKindRegistry() {
-    const registry = inject(ADDON_KIND_REGISTRY);
-    const componentCache = inject(ADDON_KIND_COMPONENT_CACHE);
-    return {
-                getKind(kind) {
-            return registry.get(kind);
-        },
-                hasKind(kind) {
-            return registry.has(kind);
-        },
-                getKindNames() {
-            return Array.from(registry.keys());
-        },
-                async loadKindComponent(kind) {
-            const definition = registry.get(kind);
-            if (!definition) {
-                const known = Array.from(registry.keys()).join(', ') || '(none)';
-                throw new DynamicFormError(`Addon kind '${kind}' is not registered. Currently registered kinds: ${known}.`);
-            }
-            const cached = componentCache.get(kind);
-            if (cached) {
-                return cached;
-            }
-            try {
-                const component = resolveDefaultExport(await definition.loadComponent());
-                if (component) {
-                    componentCache.set(kind, component);
-                    return component;
-                }
-                throw new DynamicFormError(`Addon kind '${kind}' loadComponent resolved to null.`);
-            }
-            catch (error) {
-                if (error instanceof DynamicFormError)
-                    throw error;
-                throw new DynamicFormError(`Failed to load component for addon kind '${kind}': ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-                getLoadedKindComponent(kind) {
-            if (!registry.has(kind))
-                return undefined;
-            return componentCache.get(kind);
-        },
-                get raw() {
-            return registry;
-        },
-    };
-}
-
-const BUILT_IN_ADDON_KINDS = [
+const BUILT_IN_ADDON_TYPES = [
     {
-        kind: 'text',
+        type: 'text',
         loadComponent: () => Promise.resolve().then(function () { return textAddon_component; }).then((m) => m.TextAddonComponent),
         validate: (addon, fieldKey) => {
             const text = addon.text;
                                                             if (text === undefined || text === null) {
-                throw new DynamicFormError(`Addon kind 'text' requires a 'text' field (field: '${fieldKey}').`);
+                throw new DynamicFormError(`Addon type 'text' requires a 'text' field (field: '${fieldKey}').`);
             }
             if (typeof text === 'string' && text.length === 0) {
-                throw new DynamicFormError(`Addon kind 'text' requires a non-empty 'text' string (field: '${fieldKey}').`);
+                throw new DynamicFormError(`Addon type 'text' requires a non-empty 'text' string (field: '${fieldKey}').`);
             }
         },
     },
     {
-        kind: 'template',
+        type: 'template',
         loadComponent: () => Promise.resolve().then(function () { return templateAddon_component; }).then((m) => m.TemplateAddonComponent),
         validate: (addon, fieldKey) => {
             const key = addon.templateKey;
             if (typeof key !== 'string' || key.length === 0) {
-                throw new DynamicFormError(`Addon kind 'template' requires a non-empty 'templateKey' string (field: '${fieldKey}').`);
+                throw new DynamicFormError(`Addon type 'template' requires a non-empty 'templateKey' string (field: '${fieldKey}').`);
             }
         },
     },
     {
-        kind: 'component',
+        type: 'component',
                         jsonSafe: false,
         loadComponent: () => Promise.resolve().then(function () { return componentAddon_component; }).then((m) => m.ComponentAddonComponent),
         validate: (addon, fieldKey) => {
             const loader = addon.component;
             if (typeof loader !== 'function') {
-                throw new DynamicFormError(`Addon kind 'component' requires a 'component' loader function (field: '${fieldKey}').`);
+                throw new DynamicFormError(`Addon type 'component' requires a 'component' loader function (field: '${fieldKey}').`);
             }
         },
     },
@@ -4733,28 +4671,28 @@ const DISPLAY_FIELD_TYPES_BASE = {
 const BUILT_IN_FIELDS = [
     {
         name: 'row',
-                                loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BGFguOa9.mjs'),
+                                loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-nB6KFqVs.mjs'),
         mapper: rowFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'group',
-        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-Bz4GD8Hy.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-Bq6Sgd6Z.mjs'),
         mapper: groupFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'array',
-        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-By12r5Cj.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-D5qCzJsL.mjs'),
         mapper: arrayFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'page',
-        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-CjCd5Byo.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-DRaxbiqA.mjs'),
         mapper: pageFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
@@ -4772,7 +4710,7 @@ const BUILT_IN_FIELDS = [
     },
     {
         name: 'container',
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BGFguOa9.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-nB6KFqVs.mjs'),
         mapper: containerFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
@@ -4804,8 +4742,6 @@ function createFeature(kind, providers) {
     };
 }
 
-const ADDON_KIND_DEFINITIONS = new InjectionToken('ADDON_KIND_DEFINITIONS');
-
 class ConsoleLogger {
     prefix = '[Dynamic Forms]';
     debug(message, ...args) {
@@ -4902,24 +4838,24 @@ function provideDynamicForm(...items) {
             },
         },
                                                 {
-            provide: ADDON_KIND_REGISTRY,
+            provide: ADDON_TYPE_REGISTRY,
             useFactory: () => {
                 const logger = inject(DynamicFormLogger);
-                const contributed = inject(ADDON_KIND_DEFINITIONS, { optional: true }) ?? [];
+                const contributed = inject(ADDON_TYPE_DEFINITIONS, { optional: true }) ?? [];
                 const registry = new Map();
-                for (const def of BUILT_IN_ADDON_KINDS) {
-                    registry.set(def.kind, def);
+                for (const def of BUILT_IN_ADDON_TYPES) {
+                    registry.set(def.type, def);
                 }
                 for (const def of contributed) {
-                    if (registry.has(def.kind)) {
-                        logger.warn(`Addon kind "${def.kind}" is already registered. Overwriting.`);
+                    if (registry.has(def.type)) {
+                        logger.warn(`Addon type "${def.type}" is already registered. Overwriting.`);
                     }
-                    registry.set(def.kind, def);
+                    registry.set(def.type, def);
                 }
                 return registry;
             },
         },
-                { provide: ADDON_KIND_COMPONENT_CACHE, useFactory: () => new Map() },
+                { provide: ADDON_TYPE_COMPONENT_CACHE, useFactory: () => new Map() },
         ...featureProviders,
     ]);
 }
@@ -4974,97 +4910,6 @@ function wrapperProps() {
     return undefined;
 }
 
-class DfAddonSlot {
-    registry = injectAddonKindRegistry();
-    logger = inject(DynamicFormLogger);
-    hostInjector = inject(Injector);
-    addon = input.required(/* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
-        fieldInputs = input(/* @ts-ignore */
-    ...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
-        hidden = input(undefined, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "hidden" }] : /* istanbul ignore next */ []));
-        slotAttr = computed(() => this.addon().slot, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "slotAttr" }] : /* istanbul ignore next */ []));
-    className = computed(() => this.addon().className ?? null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "className" }] : /* istanbul ignore next */ []));
-        _hiddenByValue = new WeakMap();
-    _resolvedHidden = signal(undefined, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "_resolvedHidden" }] : /* istanbul ignore next */ []));
-        isHidden = computed(() => {
-        const pre = this.hidden();
-        if (pre)
-            return pre();
-        const local = this._resolvedHidden();
-        return local ? local() : false;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "isHidden" }] : /* istanbul ignore next */ []));
-        asyncLoaded = signal(undefined, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "asyncLoaded" }] : /* istanbul ignore next */ []));
-        resolvedComponent = computed(() => {
-        const kind = this.addon().kind;
-        const cached = this.registry.getLoadedKindComponent(kind);
-        if (cached)
-            return cached;
-        const loaded = this.asyncLoaded();
-        return loaded?.kind === kind ? loaded.component : undefined;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []));
-        kindInputs = computed(() => ({
-        addon: this.addon(),
-        fieldInputs: this.fieldInputs(),
-    }), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "kindInputs" }] : /* istanbul ignore next */ []));
-    constructor() {
-                                        explicitEffect([this.addon], ([addon]) => {
-            const h = addon.hidden;
-            const valueKey = typeof h === 'object' && h !== null ? h : null;
-            let resolved = valueKey ? this._hiddenByValue.get(valueKey) : undefined;
-            if (!resolved) {
-                resolved = resolveDynamicValue(addon.hidden, false, this.hostInjector);
-                if (valueKey)
-                    this._hiddenByValue.set(valueKey, resolved);
-            }
-            this._resolvedHidden.set(resolved);
-        });
-                        explicitEffect([this.addon], ([addon]) => {
-            const kind = addon.kind;
-            if (this.registry.getLoadedKindComponent(kind))
-                return;             this.registry
-                .loadKindComponent(kind)
-                .then((component) => this.asyncLoaded.set({ kind, component }))
-                .catch((error) => {
-                this.logger.warn(`Failed to load addon kind '${kind}': ${error instanceof Error ? error.message : String(error)}. ` +
-                    `Registered kinds: ${this.registry.getKindNames().join(', ') || '(none)'}.`);
-            });
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: DfAddonSlot, isStandalone: true, selector: "df-addon-slot", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.slot": "slotAttr()", "class": "className()", "style.display": "isHidden() ? \"none\" : null" } }, ngImport: i0, template: `
-    @if (resolvedComponent(); as cmp) {
-      <ng-container *ngComponentOutlet="cmp; inputs: kindInputs()" />
-    }
-  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'df-addon-slot',
-                    imports: [NgComponentOutlet],
-                    template: `
-    @if (resolvedComponent(); as cmp) {
-      <ng-container *ngComponentOutlet="cmp; inputs: kindInputs()" />
-    }
-  `,
-                    host: {
-                        '[attr.slot]': 'slotAttr()',
-                        '[class]': 'className()',
-                        '[style.display]': 'isHidden() ? "none" : null',
-                    },
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                }]
-        }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }], hidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "hidden", required: false }] }] } });
-
 class TextAddonComponent {
     addon = input.required(/* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
@@ -5194,96 +5039,17 @@ var componentAddon_component = /*#__PURE__*/Object.freeze({
     ComponentAddonComponent: ComponentAddonComponent
 });
 
-async function runPresetAction(preset, ctx, collaborators, adapterLabel, fieldLabel) {
-                                if (ctx.form === null && preset !== 'copy' && preset !== 'paste') {
-        collaborators.logger.warn(`preset '${String(preset)}' fired without a host field context — ignoring.`);
-        return;
-    }
-                if (ctx.form !== null && (preset === 'clear' || preset === 'reset' || preset === 'paste') && ctx.form.disabled()) {
-        collaborators.logger.warn(`preset '${String(preset)}' skipped — host '${fieldLabel}' is disabled.`);
-        return;
-    }
-    switch (preset) {
-        case 'clear': {
-                                                const next = typeof ctx.value === 'string' ? '' : undefined;
-            collaborators.fieldValueSetter?.(next);
-            return;
-        }
-        case 'reset': {
-            const defaultValue = collaborators.fieldDefaultValueGetter?.();
-            collaborators.fieldValueSetter?.(defaultValue !== undefined ? defaultValue : typeof ctx.value === 'string' ? '' : undefined);
-            return;
-        }
-        case 'paste': {
-            if (typeof navigator === 'undefined' || !navigator.clipboard) {
-                collaborators.logger.warn(`preset 'paste' requires a browser clipboard API (not available in this environment).`);
-                return;
-            }
-            try {
-                const text = await navigator.clipboard.readText();
-                collaborators.fieldValueSetter?.(text);
-            }
-            catch (error) {
-                collaborators.logger.warn(`preset 'paste' clipboard read failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return;
-        }
-        case 'copy': {
-            if (typeof navigator === 'undefined' || !navigator.clipboard) {
-                collaborators.logger.warn(`preset 'copy' requires a browser clipboard API (not available in this environment).`);
-                return;
-            }
-            try {
-                                                const v = ctx.value;
-                await navigator.clipboard.writeText(v == null ? '' : String(v));
-            }
-            catch (error) {
-                collaborators.logger.warn(`preset 'copy' clipboard write failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return;
-        }
-        case 'toggle-password-visibility': {
-            const override = collaborators.typeOverride;
-            if (!override) {
-                collaborators.logger.warn(`preset 'toggle-password-visibility' has no effect outside a '${fieldLabel}' field.`);
-                return;
-            }
-                                                                                    const baseline = collaborators.baselineType?.();
-            if (baseline !== undefined && baseline !== 'password') {
-                collaborators.logger.warn(`preset 'toggle-password-visibility' refused: host '${fieldLabel}' has type '${baseline}', not 'password'.`);
-                return;
-            }
-            const current = override();
-            override.set(current === 'text' ? 'password' : 'text');
-            return;
-        }
-        default:
-            collaborators.logger.warn(`preset '${String(preset)}' is not implemented in the ${adapterLabel} adapter.`);
-    }
-}
-
-function injectFieldsSupportingAddons() {
-    const registry = inject(FIELD_REGISTRY);
-    const entries = [];
-    for (const [name, def] of registry.entries()) {
-        if (def.addons === undefined)
-            continue;
-        entries.push({ name, slots: def.addons.slots, allowedKinds: def.addons.allowedKinds });
-    }
-    return entries;
-}
-
 function withCustomAddon(definition) {
     return createFeature('addons', [
         {
-            provide: ADDON_KIND_DEFINITIONS,
+            provide: ADDON_TYPE_DEFINITIONS,
             useValue: definition,
             multi: true,
         },
     ]);
 }
 
-function provideAddonActions(handlers) {
+function withAddonActions(handlers) {
     return createFeature('addon-actions', [
         {
             provide: ADDON_ACTION_HANDLERS,
@@ -5295,9 +5061,9 @@ function provideAddonActions(handlers) {
 
 function sanitizeFormConfig(config, options = {}) {
     const fieldRegistry = inject(FIELD_REGISTRY);
-    const kindRegistry = inject(ADDON_KIND_REGISTRY);
+    const typeRegistry = inject(ADDON_TYPE_REGISTRY);
     const source = options.source ?? 'inline';
-    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, kindRegistry, source);
+    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, typeRegistry, source);
     return {
         sanitized: { ...config, fields: fields },
         warnings,
@@ -5313,9 +5079,9 @@ function logAddonWarnings(warnings, logger) {
         }
     }
 }
-function sanitizeFormConfigPure(config, fieldRegistry, kindRegistry, options = {}) {
+function sanitizeFormConfigPure(config, fieldRegistry, typeRegistry, options = {}) {
     const source = options.source ?? 'inline';
-    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, kindRegistry, source);
+    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, typeRegistry, source);
     return { sanitized: { ...config, fields: fields }, warnings };
 }
 
@@ -5332,94 +5098,7 @@ function arrayEvent(arrayKey) {
 }
 
 
-function formConfig(config) {
-    return config;
-}
-
-const CONTAINER_TYPES = ['group', 'row', 'array', 'container'];
-const HIDDEN_ONLY_LOGIC_TYPES = ['group', 'row', 'array', 'container', 'page'];
-const OPTION_FIELD_TYPES = ['select', 'radio', 'multi-checkbox'];
-const SLIDER_TYPE = 'slider';
-const HIDDEN_TYPE = 'hidden';
-function createField(type, config) {
-    const configWithProps = config;
-        if (!configWithProps['key']) {
-        throw new DynamicFormError(`createField('${type}'): 'key' property is required`);
-    }
-        if (CONTAINER_TYPES.includes(type)) {
-        if ('label' in configWithProps && configWithProps['label'] !== undefined) {
-            throw new DynamicFormError(`createField('${type}'): Container fields (${CONTAINER_TYPES.join(', ')}) do NOT support 'label'. ` +
-                `Labels go on the child fields inside the container.`);
-        }
-    }
-        if (HIDDEN_ONLY_LOGIC_TYPES.includes(type)) {
-        if ('logic' in configWithProps && configWithProps['logic'] !== undefined) {
-            const logic = configWithProps['logic'];
-            if (Array.isArray(logic)) {
-                const nonHiddenLogic = logic.filter((l) => l.type !== 'hidden');
-                if (nonHiddenLogic.length > 0) {
-                    throw new DynamicFormError(`createField('${type}'): Only 'hidden' logic type is supported. ` +
-                        `Found unsupported logic types: ${nonHiddenLogic.map((l) => l.type).join(', ')}. ` +
-                        `For other logic types, apply them to child fields instead.`);
-                }
-            }
-        }
-    }
-        if (OPTION_FIELD_TYPES.includes(type)) {
-        const props = configWithProps['props'];
-        if (props && 'options' in props) {
-            throw new DynamicFormError(`createField('${type}'): 'options' must be at FIELD level, NOT inside 'props'. ` +
-                `Move 'options' from props to the field root: { type: '${type}', key: '...', options: [...] }`);
-        }
-    }
-        if (type === SLIDER_TYPE) {
-        const props = configWithProps['props'];
-        if (props) {
-            if ('min' in props || 'max' in props) {
-                throw new DynamicFormError(`createField('slider'): Use 'minValue' and 'maxValue' at FIELD level, NOT 'min'/'max' in props. ` +
-                    `Example: { type: 'slider', key: '...', minValue: 0, maxValue: 100, step: 1 }`);
-            }
-            if ('step' in props) {
-                throw new DynamicFormError(`createField('slider'): Use 'step' at FIELD level, NOT in props. ` +
-                    `Example: { type: 'slider', key: '...', minValue: 0, maxValue: 100, step: 1 }`);
-            }
-        }
-    }
-        if (type === HIDDEN_TYPE) {
-        if ('logic' in configWithProps && configWithProps['logic'] !== undefined) {
-            throw new DynamicFormError(`createField('hidden'): Hidden fields do NOT support 'logic'. ` + `Hidden fields are purely for passing values through the form.`);
-        }
-        if ('validators' in configWithProps && configWithProps['validators'] !== undefined) {
-            throw new DynamicFormError(`createField('hidden'): Hidden fields do NOT support 'validators'. ` +
-                `Hidden fields are purely for passing values through the form.`);
-        }
-        if ('required' in configWithProps && configWithProps['required']) {
-            throw new DynamicFormError(`createField('hidden'): Hidden fields do NOT support 'required' validation. ` +
-                `Hidden fields are purely for passing values through the form.`);
-        }
-        if ('label' in configWithProps && configWithProps['label'] !== undefined) {
-            throw new DynamicFormError(`createField('hidden'): Hidden fields do NOT support 'label'. ` +
-                `Hidden fields are not rendered and have no visual representation.`);
-        }
-    }
-        if (type === 'array') {
-        if ('template' in configWithProps) {
-            throw new DynamicFormError(`createField('array'): Use 'fields' (NOT 'template') to define the array item structure. ` +
-                `Example: { type: 'array', key: '...', fields: [{ type: 'group', key: 'item', fields: [...] }] }`);
-        }
-    }
-        if (type === 'button') {
-        if (!('event' in configWithProps) || configWithProps['event'] === undefined) {
-            throw new DynamicFormError(`createField('button'): Generic buttons REQUIRE the 'event' property with a FormEventConstructor. ` +
-                `For common actions, use 'submit', 'next', or 'previous' instead which don't require event configuration. ` +
-                `Example: { type: 'submit', key: 'submit', label: 'Submit' }`);
-        }
-    }
-    return { type, ...config };
-}
-const field = createField;
-
 
 
-export { injectAddonKindRegistry as $, ArrayItemRegistryService as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DfFieldOutlet as D, EventDispatcher as E, FormStateManager as F, FormClearEvent as G, FormResetEvent as H, InsertArrayItemEvent as I, PageChangeEvent as J, PopArrayItemEvent as K, PrependArrayItemEvent as L, MoveArrayItemEvent as M, NextPageEvent as N, PreviousPageEvent as O, PROPERTY_OVERRIDE_STORE as P, SubmitEvent as Q, RemoveAtIndexEvent as R, ShiftArrayItemEvent as S, TemplateAddonComponent as T, TextAddonComponent as U, arrayEvent as V, createField as W, createWrappers as X, field as Y, formConfig as Z, formatAddonWarning as _, isSameWrapperChain as a, injectFieldsSupportingAddons as a0, isWrappersBundle as a1, logAddonWarnings as a2, provideAddonActions as a3, provideDynamicForm as a4, runPresetAction as a5, sanitizeFormConfig as a6, sanitizeFormConfigPure as a7, validateFieldAddons as a8, walkAndValidateAddons as a9, withCustomAddon as aa, withEventFormValue as ab, withLegacyStatusClasses as ac, withLoggerConfig as ad, withValidationExecutionDefaults as ae, withValueExclusionDefaults as af, wrapperProps as ag, createWrapperChainController as b, createFieldResolutionPipe as c, createSchemaFromFields as d, createHiddenSignal as e, createRenderReadySignal as f, getNormalizedArrayMetadata as g, getFieldDefaultValue as h, injectFieldRegistry as i, DEV_MODE as j, DEFAULT_DEBOUNCE_MS as k, DERIVATION_WARNING_TRACKER as l, mapFieldToInputs as m, DERIVATION_LOG_CONFIG as n, ADDON_ACTION_HANDLERS as o, ADDON_ACTION_REGISTRY as p, ADDON_KIND_COMPONENT_CACHE as q, resolveWrappers as r, ADDON_KIND_DEFINITIONS as s, traverseFieldsWithContext as t, AppendArrayItemEvent as u, ComponentAddonComponent as v, ConsoleLogger as w, DfAddonSlot as x, DfTemplate as y, DynamicForm as z };
-//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-DTkMZcnb.mjs.map
+export { withValueExclusionDefaults as $, ArrayItemRegistryService as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DfFieldOutlet as D, EventDispatcher as E, FormStateManager as F, PrependArrayItemEvent as G, PreviousPageEvent as H, InsertArrayItemEvent as I, TextAddonComponent as J, arrayEvent as K, createWrappers as L, MoveArrayItemEvent as M, NextPageEvent as N, isWrappersBundle as O, PROPERTY_OVERRIDE_STORE as P, provideDynamicForm as Q, RemoveAtIndexEvent as R, ShiftArrayItemEvent as S, TemplateAddonComponent as T, sanitizeFormConfig as U, withAddonActions as V, withCustomAddon as W, withEventFormValue as X, withLegacyStatusClasses as Y, withLoggerConfig as Z, withValidationExecutionDefaults as _, isSameWrapperChain as a, wrapperProps as a0, createWrapperChainController as b, createFieldResolutionPipe as c, createSchemaFromFields as d, createHiddenSignal as e, createRenderReadySignal as f, getNormalizedArrayMetadata as g, getFieldDefaultValue as h, injectFieldRegistry as i, DEV_MODE as j, DEFAULT_DEBOUNCE_MS as k, DERIVATION_WARNING_TRACKER as l, mapFieldToInputs as m, DERIVATION_LOG_CONFIG as n, AppendArrayItemEvent as o, ComponentAddonComponent as p, ConsoleLogger as q, resolveWrappers as r, DfTemplate as s, traverseFieldsWithContext as t, DynamicForm as u, FormClearEvent as v, FormResetEvent as w, FormSubmitEvent as x, PageChangeEvent as y, PopArrayItemEvent as z };
+//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-C59pvc26.mjs.map