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

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

@@ -0,0 +1,3372 @@
+import * as i0 from '@angular/core';
+import { isSignal, untracked, InjectionToken, inject, Injectable, linkedSignal, resourceFromSnapshots, signal, Injector, computed, Pipe } from '@angular/core';
+import { defer, combineLatest, pipe, debounceTime, distinctUntilChanged, of, from, map, catchError, tap, startWith, Subject, filter, isObservable, TimeoutError, throwError } from 'rxjs';
+import { toObservable, toSignal, rxResource } from '@angular/core/rxjs-interop';
+import { HttpClient } from '@angular/common/http';
+import { email, min, max, minLength, maxLength, pattern, required, validate, validateAsync, validateHttp } from '@angular/forms/signals';
+import { scan, map as map$1, filter as filter$1, take, switchMap, timeout, catchError as catchError$1, shareReplay } from 'rxjs/operators';
+
+function createDefaultDerivationLogConfig() {
+    return {
+        level: 'none',
+    };
+}
+function shouldLog(config, minLevel) {
+    if (config.level === 'none')
+        return false;
+    if (minLevel === 'summary')
+        return config.level === 'summary' || config.level === 'verbose';
+    return config.level === 'verbose';
+}
+function isFormStateCondition(condition) {
+    return typeof condition === 'string' && ['formInvalid', 'formSubmitting', 'pageInvalid'].includes(condition);
+}
+function isStateLogicConfig(config) {
+    return config.type === 'hidden' || config.type === 'readonly' || config.type === 'disabled' || config.type === 'required';
+}
+function isDerivationLogicConfig(config) {
+    return config.type === 'derivation';
+}
+function hasTargetProperty(config) {
+    return 'targetProperty' in config && typeof config.targetProperty === 'string' && config.targetProperty.length > 0;
+}
+
+const FORM_VALUE_ACCESS_PATTERN = /\bformValue\s*(?:\.|\[)/;
+const FORM_VALUE_PATTERN = /\bformValue\s*(?:\.([\w.]+)|\[\s*'([\w.-]+)'\s*\]|\[\s*"([\w.-]+)"\s*\])/g;
+function isCrossFieldExpression(expr, context) {
+        if (expr === undefined || typeof expr === 'boolean' || isFormStateCondition(expr)) {
+        return false;
+    }
+    switch (expr.type) {
+        case 'fieldValue':
+                        return !!expr.fieldPath;
+        case 'javascript':
+                        return FORM_VALUE_ACCESS_PATTERN.test(expr.expression || '');
+        case 'custom': {
+                                    const functionName = expr.functionName;
+            if (context?.getFunctionScope && functionName) {
+                const scope = context.getFunctionScope(functionName);
+                if (scope === 'field') {
+                                        return false;
+                }
+                            }
+                        return true;
+        }
+        case 'async':
+                                    return false;
+        case 'and':
+        case 'or':
+                        return (expr.conditions || []).some((c) => isCrossFieldExpression(c, context));
+        default:
+            return false;
+    }
+}
+function extractExpressionDependencies(expr) {
+    if (expr === undefined || typeof expr === 'boolean') {
+        return [];
+    }
+    const deps = new Set();
+    switch (expr.type) {
+        case 'fieldValue':
+            if (expr.fieldPath) {
+                                deps.add(expr.fieldPath.split('.')[0]);
+            }
+            break;
+        case 'javascript':
+                        extractFromExpressionString(expr.expression || '', deps);
+            break;
+        case 'custom':
+                        deps.add('*');
+            break;
+        case 'async':
+                        break;
+        case 'and':
+        case 'or':
+                        for (const condition of expr.conditions || []) {
+                extractExpressionDependencies(condition).forEach((d) => deps.add(d));
+            }
+            break;
+    }
+    return Array.from(deps);
+}
+function extractStringDependencies(expression) {
+    const deps = new Set();
+    extractFromExpressionString(expression, deps);
+    return Array.from(deps);
+}
+function extractFromExpressionString(expression, deps) {
+    for (const match of expression.matchAll(FORM_VALUE_PATTERN)) {
+        const fullPath = match[1] ?? match[2] ?? match[3];
+        if (!fullPath)
+            continue;
+                const rootField = fullPath.split('.')[0];
+        deps.add(rootField);
+                if (fullPath.includes('.')) {
+            deps.add(fullPath);
+        }
+    }
+}
+function isCrossFieldValidator(config) {
+    if (!config.expression) {
+        return false;
+    }
+    return FORM_VALUE_ACCESS_PATTERN.test(config.expression);
+}
+function isCrossFieldBuiltInValidator(config) {
+    if (config.type === 'custom') {
+        return false;     }
+        if ('expression' in config && typeof config.expression === 'string') {
+        return FORM_VALUE_ACCESS_PATTERN.test(config.expression);
+    }
+    return false;
+}
+function isResourceBasedValidator(config) {
+    return config.type === 'async' || config.type === 'http';
+}
+function hasCrossFieldWhenCondition(config, context) {
+    if (!('when' in config) || !config.when) {
+        return false;
+    }
+    return isCrossFieldExpression(config.when, context);
+}
+function isCrossFieldStateLogic(config, context) {
+    return isCrossFieldExpression(config.condition, context);
+}
+function isCrossFieldSchema(config, context) {
+    if (config.type !== 'applyWhen' || !config.condition) {
+        return false;
+    }
+    return isCrossFieldExpression(config.condition, context);
+}
+
+const STATE_PROPERTIES = ['touched', 'dirty', 'valid', 'invalid', 'pending', 'hidden', 'readonly', 'disabled'];
+function readStateSignal(fieldState, prop, reactive) {
+    const signalFn = fieldState[prop];
+    if (!signalFn || !isSignal(signalFn))
+        return false;
+    return reactive ? !!signalFn() : !!untracked(signalFn);
+}
+function resolveFieldState(fieldSource, reactive) {
+    if (!fieldSource)
+        return undefined;
+        if (typeof fieldSource === 'function') {
+        return reactive ? fieldSource() : untracked(fieldSource);
+    }
+        if (typeof fieldSource === 'object') {
+        return fieldSource;
+    }
+    return undefined;
+}
+function readFieldStateInfo(fieldSource, reactive) {
+    const state = resolveFieldState(fieldSource, reactive);
+    if (!state || typeof state !== 'object')
+        return undefined;
+    const knownProperties = new Set([...STATE_PROPERTIES, 'pristine']);
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop === 'pristine') {
+                return !readStateSignal(state, 'dirty', reactive);
+            }
+            if (STATE_PROPERTIES.includes(prop)) {
+                return readStateSignal(state, prop, reactive);
+            }
+            return false;
+        },
+        has(_target, prop) {
+            return knownProperties.has(prop);
+        },
+    });
+}
+function createFormFieldStateMap(rootForm, reactive) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get(_target, key) {
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+            const fieldAccessor = navigateToFieldAccessor(rootForm, key);
+            const snapshot = readFieldStateInfo(fieldAccessor, reactive);
+            cache.set(key, snapshot);
+            return snapshot;
+        },
+        has(_target, key) {
+            return navigateToFieldAccessor(rootForm, key) !== undefined;
+        },
+    });
+}
+function navigateToFieldAccessor(rootForm, keyPath) {
+    if (!keyPath)
+        return undefined;
+    const parts = keyPath.split('.');
+            let current = rootForm;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const next = current[parts[i]];
+        if (!next)
+            return undefined;
+        current = next;
+    }
+    return current[parts[parts.length - 1]];
+}
+
+class AsyncConditionFunctionCacheService {
+        asyncConditionFunctionCache = new Map();
+}
+
+function stableStringify(value) {
+    if (value === null || value === undefined) {
+        return String(value);
+    }
+    if (typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return '[' + value.map(stableStringify).join(',') + ']';
+    }
+    const obj = value;
+    const sortedKeys = Object.keys(obj).sort();
+    const pairs = sortedKeys.map((key) => JSON.stringify(key) + ':' + stableStringify(obj[key]));
+    return '{' + pairs.join(',') + '}';
+}
+
+class DynamicFormError extends Error {
+    static PREFIX = '[Dynamic Forms]';
+    constructor(message) {
+        super(`${DynamicFormError.PREFIX} ${message}`);
+        this.name = 'DynamicFormError';
+    }
+}
+
+const DEFAULT_WRAPPERS = new InjectionToken('DEFAULT_WRAPPERS');
+const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT');
+function injectFieldSignalContext() {
+    const ctx = inject(FIELD_SIGNAL_CONTEXT, { optional: true });
+    if (!ctx) {
+        throw new DynamicFormError('FIELD_SIGNAL_CONTEXT is not provided. This consumer must run inside a <df-dynamic-form> component tree.');
+    }
+    return ctx;
+}
+const ARRAY_CONTEXT = new InjectionToken('ARRAY_CONTEXT');
+const GROUP_CONTEXT = new InjectionToken('GROUP_CONTEXT');
+const DEFAULT_PROPS = new InjectionToken('DEFAULT_PROPS');
+const DEFAULT_VALIDATION_MESSAGES = new InjectionToken('DEFAULT_VALIDATION_MESSAGES');
+const FORM_OPTIONS = new InjectionToken('FORM_OPTIONS');
+const EXTERNAL_DATA = new InjectionToken('EXTERNAL_DATA');
+const FORM_ID_PREFIX = new InjectionToken('FORM_ID_PREFIX');
+
+class RootFormRegistryService {
+    formValue;
+    rootForm;
+    constructor(formValue, rootForm) {
+        this.formValue = formValue;
+        this.rootForm = rootForm;
+    }
+}
+
+const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
+
+const DEPRECATION_WARNING_TRACKER = new InjectionToken('DeprecationWarningTracker');
+
+function compareValues(actual, expected, operator) {
+    switch (operator) {
+        case 'equals':
+            return actual === expected;
+        case 'notEquals':
+            return actual !== expected;
+        case 'greater':
+            return Number(actual) > Number(expected);
+        case 'less':
+            return Number(actual) < Number(expected);
+        case 'greaterOrEqual':
+            return Number(actual) >= Number(expected);
+        case 'lessOrEqual':
+            return Number(actual) <= Number(expected);
+        case 'contains':
+            return String(actual).includes(String(expected));
+        case 'startsWith':
+            return String(actual).startsWith(String(expected));
+        case 'endsWith':
+            return String(actual).endsWith(String(expected));
+        case 'matches':
+            try {
+                return toRegExp(String(expected)).test(String(actual));
+            }
+            catch {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
+function toRegExp(value) {
+    const literal = /^\/(.+)\/([dgimsuvy]*)$/.exec(value);
+    return literal ? new RegExp(literal[1], literal[2]) : new RegExp(value);
+}
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((current, key) => {
+        return current && typeof current === 'object' ? current[key] : undefined;
+    }, obj);
+}
+function hasNestedProperty(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!current || typeof current !== 'object')
+            return false;
+        current = current[keys[i]];
+    }
+    if (!current || typeof current !== 'object')
+        return false;
+    return keys[keys.length - 1] in current;
+}
+
+function safeReadPathKeys(fieldContext) {
+    if (!('pathKeys' in fieldContext) || typeof fieldContext.pathKeys !== 'function') {
+        return [];
+    }
+    return untracked(() => fieldContext.pathKeys());
+}
+
+function isChildFieldContext(context) {
+    return 'key' in context && isSignal(context.key);
+}
+function extractFieldState(fieldContext) {
+    return untracked(() => {
+        if (!fieldContext || !('state' in fieldContext))
+            return undefined;
+        return fieldContext.state;
+    });
+}
+function detectArrayScope(pathKeys) {
+        if (pathKeys.length < 3)
+        return undefined;
+                for (let i = pathKeys.length - 2; i >= 1; i--) {
+        const maybeIndex = Number(pathKeys[i]);
+        if (Number.isInteger(maybeIndex) && maybeIndex >= 0) {
+            return {
+                arrayKey: pathKeys.slice(0, i).join('.'),
+                index: maybeIndex,
+                localKey: pathKeys[pathKeys.length - 1],
+            };
+        }
+    }
+    return undefined;
+}
+class FieldContextRegistryService {
+    rootFormRegistry = inject(RootFormRegistryService);
+    logger = inject(DynamicFormLogger);
+    deprecationTracker = inject(DEPRECATION_WARNING_TRACKER, { optional: true });
+    externalDataSignal = inject(EXTERNAL_DATA, { optional: true });
+        createEvaluationContext(fieldContext, customFunctions) {
+                        const fieldValue = untracked(() => fieldContext.value());
+                                const rootFormValue = untracked(() => this.rootFormRegistry.formValue());
+        const localKey = this.extractFieldPath(fieldContext);
+        const pathKeys = safeReadPathKeys(fieldContext);
+        const arrayScope = detectArrayScope(pathKeys);
+        if (arrayScope) {
+            return this.buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, false, fieldContext);
+        }
+                                        const rootFormSignal = this.rootFormRegistry.rootForm;
+        return {
+            fieldValue,
+            formValue: rootFormValue,
+            fieldPath: localKey,
+            customFunctions: customFunctions || {},
+            externalData: this.resolveExternalData(false),
+            logger: this.logger,
+            deprecationTracker: this.deprecationTracker ?? undefined,
+            get fieldState() {
+                return readFieldStateInfo(extractFieldState(fieldContext), false);
+            },
+            get formFieldState() {
+                return createFormFieldStateMap(untracked(rootFormSignal), false);
+            },
+        };
+    }
+        extractFieldPath(fieldContext) {
+        if (isChildFieldContext(fieldContext)) {
+            try {
+                return String(fieldContext.key());
+            }
+            catch (error) {
+                this.logger.warn('Unable to extract field key:', error);
+            }
+        }
+                return '';
+    }
+        buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, reactive, fieldContext) {
+        const { arrayKey, index, localKey } = arrayScope;
+                const arrayData = getNestedValue(rootFormValue, arrayKey);
+        let scopedFormValue;
+        if (Array.isArray(arrayData) && index >= 0 && index < arrayData.length) {
+            const item = arrayData[index];
+            if (item != null && typeof item === 'object') {
+                scopedFormValue = item;
+            }
+        }
+                                const rootFormSignal = this.rootFormRegistry.rootForm;
+        const fieldStateGetter = fieldContext ? () => readFieldStateInfo(extractFieldState(fieldContext), reactive) : () => undefined;
+        const formFieldStateGetter = () => createFormFieldStateMap((reactive ? rootFormSignal() : untracked(rootFormSignal)), reactive);
+                if (!scopedFormValue) {
+            return {
+                fieldValue,
+                formValue: rootFormValue,
+                fieldPath: localKey,
+                customFunctions: customFunctions || {},
+                externalData: this.resolveExternalData(reactive),
+                logger: this.logger,
+                deprecationTracker: this.deprecationTracker ?? undefined,
+                get fieldState() {
+                    return fieldStateGetter();
+                },
+                get formFieldState() {
+                    return formFieldStateGetter();
+                },
+            };
+        }
+        return {
+            fieldValue,
+            formValue: scopedFormValue,
+            rootFormValue,
+            arrayIndex: index,
+            arrayPath: arrayKey,
+            fieldPath: `${arrayKey}.${index}.${localKey}`,
+            customFunctions: customFunctions || {},
+            externalData: this.resolveExternalData(reactive),
+            logger: this.logger,
+            deprecationTracker: this.deprecationTracker ?? undefined,
+            get fieldState() {
+                return fieldStateGetter();
+            },
+            get formFieldState() {
+                return formFieldStateGetter();
+            },
+        };
+    }
+        resolveExternalData(reactive) {
+        const externalDataSignal = this.externalDataSignal;
+        if (!externalDataSignal)
+            return undefined;
+        const externalDataRecord = reactive ? externalDataSignal() : untracked(() => externalDataSignal());
+        if (!externalDataRecord) {
+            return undefined;
+        }
+        const resolved = {};
+        for (const [key, value] of Object.entries(externalDataRecord)) {
+            if (!isSignal(value)) {
+                throw new DynamicFormError(`externalData["${key}"] must be a Signal. Got: ${typeof value}. Wrap it with signal(yourValue).`);
+            }
+            resolved[key] = reactive ? value() : untracked(() => value());
+        }
+        return resolved;
+    }
+        createReactiveEvaluationContext(fieldContext, customFunctions) {
+        const fieldValue = fieldContext.value();
+        const rootFormValue = this.rootFormRegistry.formValue();
+        const pathKeys = safeReadPathKeys(fieldContext);
+        const arrayScope = detectArrayScope(pathKeys);
+        if (arrayScope) {
+            return this.buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, true, fieldContext);
+        }
+        const localKey = this.extractFieldPath(fieldContext);
+        const rootFormSignal = this.rootFormRegistry.rootForm;
+        return {
+            fieldValue,
+            formValue: rootFormValue,
+            fieldPath: localKey,
+            customFunctions: customFunctions || {},
+            externalData: this.resolveExternalData(true),
+            logger: this.logger,
+            deprecationTracker: this.deprecationTracker ?? undefined,
+            get fieldState() {
+                return readFieldStateInfo(extractFieldState(fieldContext), true);
+            },
+            get formFieldState() {
+                return createFormFieldStateMap(rootFormSignal(), true);
+            },
+        };
+    }
+        createDisplayOnlyContext(fieldPath, customFunctions) {
+        const formValue = this.rootFormRegistry.formValue();
+        const rootFormSignal = this.rootFormRegistry.rootForm;
+        return {
+            fieldValue: undefined,
+            formValue,
+            fieldPath,
+            customFunctions: customFunctions || {},
+            externalData: this.resolveExternalData(true),
+            logger: this.logger,
+            deprecationTracker: this.deprecationTracker ?? undefined,
+            get formFieldState() {
+                return createFormFieldStateMap(rootFormSignal(), true);
+            },
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService, decorators: [{
+            type: Injectable
+        }] });
+
+class FunctionRegistryService {
+    customFunctions = new Map();
+    customFunctionScopes = new Map();
+    derivationFunctions = new Map();
+    asyncDerivationFunctions = new Map();
+    asyncConditionFunctions = new Map();
+    validators = new Map();
+    asyncValidators = new Map();
+    httpValidators = new Map();
+        registerCustomFunction(name, fn, options) {
+        this.customFunctions.set(name, fn);
+                this.customFunctionScopes.set(name, options?.scope ?? 'form');
+    }
+        getCustomFunctionScope(name) {
+        return this.customFunctionScopes.get(name);
+    }
+        isFieldScopedFunction(name) {
+        return this.customFunctionScopes.get(name) === 'field';
+    }
+        getCustomFunctions() {
+        return Object.fromEntries(this.customFunctions);
+    }
+        clearCustomFunctions() {
+        this.customFunctions.clear();
+        this.customFunctionScopes.clear();
+    }
+                    registerDerivationFunction(name, fn) {
+        this.derivationFunctions.set(name, fn);
+    }
+        getDerivationFunction(name) {
+        return this.derivationFunctions.get(name);
+    }
+        getDerivationFunctions() {
+        return Object.fromEntries(this.derivationFunctions);
+    }
+        setDerivationFunctions(derivations) {
+        this.setRegistryIfChanged(this.derivationFunctions, derivations);
+    }
+        clearDerivationFunctions() {
+        this.derivationFunctions.clear();
+    }
+                    registerAsyncDerivationFunction(name, fn) {
+        this.asyncDerivationFunctions.set(name, fn);
+    }
+        getAsyncDerivationFunction(name) {
+        return this.asyncDerivationFunctions.get(name);
+    }
+        getAsyncDerivationFunctions() {
+        return Object.fromEntries(this.asyncDerivationFunctions);
+    }
+        setAsyncDerivationFunctions(fns) {
+        this.setRegistryIfChanged(this.asyncDerivationFunctions, fns);
+    }
+        clearAsyncDerivationFunctions() {
+        this.asyncDerivationFunctions.clear();
+    }
+                    registerAsyncConditionFunction(name, fn) {
+        this.asyncConditionFunctions.set(name, fn);
+    }
+        getAsyncConditionFunction(name) {
+        return this.asyncConditionFunctions.get(name);
+    }
+        getAsyncConditionFunctions() {
+        return Object.fromEntries(this.asyncConditionFunctions);
+    }
+        setAsyncConditionFunctions(fns) {
+        this.setRegistryIfChanged(this.asyncConditionFunctions, fns);
+    }
+        clearAsyncConditionFunctions() {
+        this.asyncConditionFunctions.clear();
+    }
+        registerValidator(name, fn) {
+        this.validators.set(name, fn);
+    }
+        getValidator(name) {
+        return this.validators.get(name);
+    }
+        clearValidators() {
+        this.validators.clear();
+    }
+        registerAsyncValidator(name, fn) {
+        this.asyncValidators.set(name, fn);
+    }
+        getAsyncValidator(name) {
+        return this.asyncValidators.get(name);
+    }
+        clearAsyncValidators() {
+        this.asyncValidators.clear();
+    }
+        registerHttpValidator(name, config) {
+        this.httpValidators.set(name, config);
+    }
+        getHttpValidator(name) {
+        return this.httpValidators.get(name);
+    }
+        clearHttpValidators() {
+        this.httpValidators.clear();
+    }
+        setRegistryIfChanged(registry, values) {
+        if (!values)
+            return;
+        const entries = Object.entries(values);
+        const hasChanges = entries.some(([name, value]) => registry.get(name) !== value);
+        if (hasChanges) {
+            entries.forEach(([name, value]) => registry.set(name, value));
+        }
+    }
+        setValidators(validators) {
+        this.setRegistryIfChanged(this.validators, validators);
+    }
+        setAsyncValidators(asyncValidators) {
+        this.setRegistryIfChanged(this.asyncValidators, asyncValidators);
+    }
+        setHttpValidators(httpValidators) {
+        this.setRegistryIfChanged(this.httpValidators, httpValidators);
+    }
+        clearAll() {
+        this.clearCustomFunctions();
+        this.clearDerivationFunctions();
+        this.clearAsyncDerivationFunctions();
+        this.clearAsyncConditionFunctions();
+        this.clearValidators();
+        this.clearAsyncValidators();
+        this.clearHttpValidators();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService, decorators: [{
+            type: Injectable
+        }] });
+
+function isSignalArray(value) {
+    return Array.isArray(value) && value.every((item) => isSignal(item));
+}
+function isSignalRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.values(value).every((item) => isSignal(item));
+}
+function derivedFromDeferred(source, operator, options) {
+    const deferred$ = defer(() => {
+                if (isSignal(source)) {
+            return toObservable(source, { injector: options.injector });
+        }
+                if (isSignalArray(source)) {
+            const observables = source.map((s) => toObservable(s, { injector: options.injector }));
+            return combineLatest(observables);
+        }
+                if (isSignalRecord(source)) {
+            const keys = Object.keys(source);
+            const observables = keys.map((key) => toObservable(source[key], { injector: options.injector }));
+            return combineLatest(observables, (...values) => {
+                const result = {};
+                keys.forEach((key, index) => {
+                    result[key] = values[index];
+                });
+                return result;
+            });
+        }
+                throw new Error('Invalid source type. Expected a Signal, array of Signals, or object of Signals.');
+    }).pipe(operator);
+    return toSignal(deferred$, { initialValue: options.initialValue, injector: options.injector });
+}
+
+function withPreviousValue(input) {
+    const derived = linkedSignal({ ...(ngDevMode ? { debugName: "derived" } : /* istanbul ignore next */ {}), source: input.snapshot,
+        computation: (snapshot, previous) => {
+                                    if ((snapshot.status === 'loading' || snapshot.status === 'reloading') &&
+                previous !== undefined &&
+                previous.value.status !== 'error') {
+                return { status: snapshot.status, value: previous.value.value };
+            }
+            return snapshot;
+        } });
+    return resourceFromSnapshots(derived);
+}
+
+function createDebouncedResourceLogicFn(config) {
+    const perFunctionSignalStore = new Map();
+    return (ctx) => {
+        const contextKey = safeReadPathKeys(ctx).join('.');
+        let handle = perFunctionSignalStore.get(contextKey);
+        if (!handle) {
+            const trigger = signal(undefined, ...(ngDevMode ? [{ debugName: "trigger" }] : /* istanbul ignore next */ []));
+                                                            const resultResource = untracked(() => {
+                const debouncedTrigger = derivedFromDeferred(trigger, pipe(debounceTime(config.debounceMs), 
+                                                distinctUntilChanged((a, b) => a?.key === b?.key)), { initialValue: undefined, injector: config.injector });
+                const resource = rxResource({
+                    params: () => debouncedTrigger(),
+                                        stream: ({ params }) => config.buildStream(params.payload),
+                    defaultValue: config.pendingValue,
+                    injector: config.injector,
+                });
+                return withPreviousValue(resource);
+            });
+            handle = { trigger, resultResource, refetchVersion: 0 };
+            perFunctionSignalStore.set(contextKey, handle);
+        }
+        const resolved = config.resolve(ctx);
+        if (resolved.kind === 'returnEarly') {
+            handle.refetchVersion++;
+            return resolved.value;
+        }
+        if (resolved.kind === 'holdPrevious') {
+            return handle.resultResource.value();
+        }
+        const dedupKey = `${resolved.key}::${handle.refetchVersion}`;
+        const newTrigger = { key: dedupKey, payload: resolved.payload };
+        untracked(() => {
+            const current = handle.trigger();
+                        if (current?.key !== newTrigger.key) {
+                handle.trigger.set(newTrigger);
+            }
+        });
+        return handle.resultResource.value();
+    };
+}
+
+function createAsyncConditionLogicFunction(condition) {
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const functionRegistry = inject(FunctionRegistryService);
+    const injector = inject(Injector);
+    const logger = inject(DynamicFormLogger);
+    const cacheService = inject(AsyncConditionFunctionCacheService);
+    const pendingValue = condition.pendingValue ?? false;
+    const debounceMs = condition.debounceMs ?? 300;
+    if (condition.asyncFn && condition.asyncFunctionName) {
+        logger.warn('Both "asyncFn" and "asyncFunctionName" are set on async condition. Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.');
+    }
+                const cacheKey = condition.asyncFn ? undefined : stableStringify(condition);
+    if (cacheKey !== undefined) {
+        const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    const fn = createDebouncedResourceLogicFn({
+        pendingValue,
+        debounceMs,
+        injector,
+        resolve: (ctx) => {
+                                                const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+            const key = stableStringify({
+                formValue: evaluationContext.formValue,
+                fieldValue: evaluationContext.fieldValue,
+                externalData: evaluationContext.externalData,
+            });
+            return { kind: 'trigger', key, payload: ctx };
+        },
+        buildStream: (capturedCtx) => {
+                                    const asyncFn = condition.asyncFn ??
+                (condition.asyncFunctionName ? functionRegistry.getAsyncConditionFunction(condition.asyncFunctionName) : undefined);
+            if (!asyncFn) {
+                logger.warn(`Async Condition - function '${condition.asyncFunctionName}' not found. ` + `Register it in customFnConfig.asyncConditions.`);
+                return of(pendingValue);
+            }
+            const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(capturedCtx, functionRegistry.getCustomFunctions());
+                                    return from(asyncFn(evaluationContext)).pipe(map((result) => !!result), catchError((error) => {
+                logger.warn('Async Condition - function failed:', error);
+                return of(pendingValue);
+            }));
+        },
+    });
+    if (cacheKey !== undefined) {
+        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    }
+    return fn;
+}
+
+var TokenType;
+(function (TokenType) {
+        TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["TRUE"] = "TRUE";
+    TokenType["FALSE"] = "FALSE";
+    TokenType["NULL"] = "NULL";
+    TokenType["UNDEFINED"] = "UNDEFINED";
+        TokenType["IDENTIFIER"] = "IDENTIFIER";
+        TokenType["PLUS"] = "PLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["MULTIPLY"] = "MULTIPLY";
+    TokenType["DIVIDE"] = "DIVIDE";
+    TokenType["MODULO"] = "MODULO";
+        TokenType["EQUAL"] = "EQUAL";
+    TokenType["NOT_EQUAL"] = "NOT_EQUAL";
+    TokenType["GREATER"] = "GREATER";
+    TokenType["LESS"] = "LESS";
+    TokenType["GREATER_EQUAL"] = "GREATER_EQUAL";
+    TokenType["LESS_EQUAL"] = "LESS_EQUAL";
+        TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["NOT"] = "NOT";
+        TokenType["DOT"] = "DOT";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["COLON"] = "COLON";
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["ARROW"] = "ARROW";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["OPTIONAL_DOT"] = "OPTIONAL_DOT";
+        TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+class ExpressionParserError extends DynamicFormError {
+    position;
+    expression;
+    constructor(message, position, expression) {
+        super(`${message} at position ${position} in expression: ${expression}`);
+        this.position = position;
+        this.expression = expression;
+        this.name = 'ExpressionParserError';
+    }
+}
+
+class Tokenizer {
+    position = 0;
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+        tokenize() {
+        const tokens = [];
+        while (this.position < this.expression.length) {
+            this.skipWhitespace();
+            if (this.position >= this.expression.length) {
+                break;
+            }
+            const token = this.nextToken();
+            tokens.push(token);
+        }
+        tokens.push({ type: TokenType.EOF, value: '', position: this.position });
+        return tokens;
+    }
+    skipWhitespace() {
+        while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
+            this.position++;
+        }
+    }
+    nextToken() {
+        const char = this.expression[this.position];
+                if (char === '"' || char === "'") {
+            return this.readString(char);
+        }
+                if (/[0-9]/.test(char)) {
+            return this.readNumber();
+        }
+                if (/[a-zA-Z_$]/.test(char)) {
+            return this.readIdentifierOrKeyword();
+        }
+                return this.readOperatorOrPunctuation();
+    }
+    readString(quote) {
+        const start = this.position;
+        this.position++;         let value = '';
+        while (this.position < this.expression.length) {
+            const char = this.expression[this.position];
+            if (char === quote) {
+                this.position++;                 return { type: TokenType.STRING, value, position: start };
+            }
+            if (char === '\\' && this.position + 1 < this.expression.length) {
+                                this.position++;
+                const nextChar = this.expression[this.position];
+                switch (nextChar) {
+                    case 'n':
+                        value += '\n';
+                        break;
+                    case 't':
+                        value += '\t';
+                        break;
+                    case 'r':
+                        value += '\r';
+                        break;
+                    case '\\':
+                        value += '\\';
+                        break;
+                    case quote:
+                        value += quote;
+                        break;
+                    default:
+                        value += nextChar;
+                }
+                this.position++;
+            }
+            else {
+                value += char;
+                this.position++;
+            }
+        }
+        throw new ExpressionParserError('Unterminated string literal', start, this.expression);
+    }
+    readNumber() {
+        const start = this.position;
+        let value = '';
+        while (this.position < this.expression.length && /[0-9.]/.test(this.expression[this.position])) {
+            value += this.expression[this.position];
+            this.position++;
+        }
+        if (!/^\d+(\.\d+)?$/.test(value)) {
+            throw new ExpressionParserError(`Invalid number: ${value}`, start, this.expression);
+        }
+        return { type: TokenType.NUMBER, value, position: start };
+    }
+    readIdentifierOrKeyword() {
+        const start = this.position;
+        let value = '';
+        while (this.position < this.expression.length && /[a-zA-Z0-9_$]/.test(this.expression[this.position])) {
+            value += this.expression[this.position];
+            this.position++;
+        }
+                const type = this.getKeywordType(value);
+        return { type, value, position: start };
+    }
+    getKeywordType(value) {
+        switch (value) {
+            case 'true':
+                return TokenType.TRUE;
+            case 'false':
+                return TokenType.FALSE;
+            case 'null':
+                return TokenType.NULL;
+            case 'undefined':
+                return TokenType.UNDEFINED;
+            default:
+                return TokenType.IDENTIFIER;
+        }
+    }
+    readOperatorOrPunctuation() {
+        const start = this.position;
+        const char = this.expression[this.position];
+        const nextChar = this.position + 1 < this.expression.length ? this.expression[this.position + 1] : '';
+        const thirdChar = this.position + 2 < this.expression.length ? this.expression[this.position + 2] : '';
+                const threeChar = char + nextChar + thirdChar;
+        if (threeChar === '===') {
+            this.position += 3;
+            return { type: TokenType.EQUAL, value: '===', position: start };
+        }
+        if (threeChar === '!==') {
+            this.position += 3;
+            return { type: TokenType.NOT_EQUAL, value: '!==', position: start };
+        }
+                const twoChar = char + nextChar;
+        switch (twoChar) {
+            case '==':
+                this.position += 2;
+                return { type: TokenType.EQUAL, value: '==', position: start };
+            case '!=':
+                this.position += 2;
+                return { type: TokenType.NOT_EQUAL, value: '!=', position: start };
+            case '>=':
+                this.position += 2;
+                return { type: TokenType.GREATER_EQUAL, value: '>=', position: start };
+            case '<=':
+                this.position += 2;
+                return { type: TokenType.LESS_EQUAL, value: '<=', position: start };
+            case '&&':
+                this.position += 2;
+                return { type: TokenType.AND, value: '&&', position: start };
+            case '||':
+                this.position += 2;
+                return { type: TokenType.OR, value: '||', position: start };
+            case '=>':
+                this.position += 2;
+                return { type: TokenType.ARROW, value: '=>', position: start };
+            case '?.':
+                this.position += 2;
+                return { type: TokenType.OPTIONAL_DOT, value: '?.', position: start };
+        }
+                this.position++;
+        switch (char) {
+            case '+':
+                return { type: TokenType.PLUS, value: '+', position: start };
+            case '-':
+                return { type: TokenType.MINUS, value: '-', position: start };
+            case '*':
+                return { type: TokenType.MULTIPLY, value: '*', position: start };
+            case '/':
+                return { type: TokenType.DIVIDE, value: '/', position: start };
+            case '%':
+                return { type: TokenType.MODULO, value: '%', position: start };
+            case '>':
+                return { type: TokenType.GREATER, value: '>', position: start };
+            case '<':
+                return { type: TokenType.LESS, value: '<', position: start };
+            case '!':
+                return { type: TokenType.NOT, value: '!', position: start };
+            case '.':
+                return { type: TokenType.DOT, value: '.', position: start };
+            case ',':
+                return { type: TokenType.COMMA, value: ',', position: start };
+            case ':':
+                return { type: TokenType.COLON, value: ':', position: start };
+            case '(':
+                return { type: TokenType.LPAREN, value: '(', position: start };
+            case ')':
+                return { type: TokenType.RPAREN, value: ')', position: start };
+            case '[':
+                return { type: TokenType.LBRACKET, value: '[', position: start };
+            case ']':
+                return { type: TokenType.RBRACKET, value: ']', position: start };
+            case '{':
+                return { type: TokenType.LBRACE, value: '{', position: start };
+            case '}':
+                return { type: TokenType.RBRACE, value: '}', position: start };
+            case '?':
+                return { type: TokenType.QUESTION, value: '?', position: start };
+            default:
+                throw new ExpressionParserError(`Unexpected character: ${char}`, start, this.expression);
+        }
+    }
+}
+
+class Parser {
+    tokens = [];
+    current = 0;
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+        parse() {
+        const tokenizer = new Tokenizer(this.expression);
+        this.tokens = tokenizer.tokenize();
+        this.current = 0;
+        if (this.isAtEnd()) {
+            throw new ExpressionParserError('Empty expression', 0, this.expression);
+        }
+        const result = this.parseExpression();
+        if (!this.isAtEnd()) {
+            const token = this.peek();
+            throw new ExpressionParserError(`Unexpected token '${token.value}' at position ${token.position} — expression has trailing content`, token.position, this.expression);
+        }
+        return result;
+    }
+    parseExpression() {
+                        const arrow = this.tryParseArrowFunction();
+        if (arrow)
+            return arrow;
+        return this.parseConditional();
+    }
+        parseConditional() {
+        const test = this.parseLogicalOr();
+        if (!this.match(TokenType.QUESTION))
+            return test;
+        const consequent = this.parseExpression();
+        this.consume(TokenType.COLON, 'Expected ":" between ternary branches');
+        const alternate = this.parseExpression();
+        return { type: 'Conditional', test, consequent, alternate };
+    }
+        tryParseArrowFunction() {
+        const savedPos = this.current;
+                if (this.check(TokenType.IDENTIFIER) && this.checkAt(this.current + 1, TokenType.ARROW)) {
+            const param = this.advance().value;
+            this.advance();             const body = this.parseExpression();
+            return { type: 'ArrowFunction', params: [param], body };
+        }
+                if (this.check(TokenType.LPAREN)) {
+            this.advance();             const params = [];
+            if (this.check(TokenType.RPAREN)) {
+                this.advance();             }
+            else if (this.check(TokenType.IDENTIFIER)) {
+                params.push(this.advance().value);
+                while (this.check(TokenType.COMMA)) {
+                    this.advance();                     if (!this.check(TokenType.IDENTIFIER)) {
+                        this.current = savedPos;
+                        return null;
+                    }
+                    params.push(this.advance().value);
+                }
+                if (!this.check(TokenType.RPAREN)) {
+                    this.current = savedPos;
+                    return null;
+                }
+                this.advance();             }
+            else {
+                this.current = savedPos;
+                return null;
+            }
+            if (!this.check(TokenType.ARROW)) {
+                this.current = savedPos;
+                return null;
+            }
+            this.advance();             const body = this.parseExpression();
+            return { type: 'ArrowFunction', params, body };
+        }
+        return null;
+    }
+    checkAt(index, type) {
+        if (index < 0 || index >= this.tokens.length)
+            return false;
+        return this.tokens[index].type === type;
+    }
+    parseLogicalOr() {
+        let node = this.parseLogicalAnd();
+        while (this.match(TokenType.OR)) {
+            const operator = this.previous().value;
+            const right = this.parseLogicalAnd();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseLogicalAnd() {
+        let node = this.parseEquality();
+        while (this.match(TokenType.AND)) {
+            const operator = this.previous().value;
+            const right = this.parseEquality();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseEquality() {
+        let node = this.parseComparison();
+        while (this.match(TokenType.EQUAL, TokenType.NOT_EQUAL)) {
+            const operator = this.previous().value;
+            const right = this.parseComparison();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseComparison() {
+        let node = this.parseAddition();
+        while (this.match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL)) {
+            const operator = this.previous().value;
+            const right = this.parseAddition();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseAddition() {
+        let node = this.parseMultiplication();
+        while (this.match(TokenType.PLUS, TokenType.MINUS)) {
+            const operator = this.previous().value;
+            const right = this.parseMultiplication();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseMultiplication() {
+        let node = this.parseUnary();
+        while (this.match(TokenType.MULTIPLY, TokenType.DIVIDE, TokenType.MODULO)) {
+            const operator = this.previous().value;
+            const right = this.parseUnary();
+            node = { type: 'BinaryOp', operator, left: node, right };
+        }
+        return node;
+    }
+    parseUnary() {
+        if (this.match(TokenType.NOT, TokenType.MINUS, TokenType.PLUS)) {
+            const operator = this.previous().value;
+            const operand = this.parseUnary();
+            return { type: 'UnaryOp', operator, operand };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let node = this.parsePrimary();
+        while (true) {
+            if (this.match(TokenType.DOT)) {
+                                if (!this.check(TokenType.IDENTIFIER)) {
+                    throw new ExpressionParserError('Expected property name after "."', this.peek().position, this.expression);
+                }
+                const property = this.advance().value;
+                node = { type: 'MemberAccess', object: node, property };
+            }
+            else if (this.match(TokenType.OPTIONAL_DOT)) {
+                                if (this.match(TokenType.LBRACKET)) {
+                    const property = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                    node = { type: 'ComputedMemberAccess', object: node, property, optional: true };
+                }
+                else if (this.match(TokenType.LPAREN)) {
+                    const args = this.parseArgumentList();
+                    this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
+                    node = { type: 'CallExpression', callee: node, arguments: args, optional: true };
+                }
+                else if (this.check(TokenType.IDENTIFIER)) {
+                    const property = this.advance().value;
+                    node = { type: 'MemberAccess', object: node, property, optional: true };
+                }
+                else {
+                    throw new ExpressionParserError('Expected property name, "[", or "(" after "?."', this.peek().position, this.expression);
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                                const property = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                node = { type: 'ComputedMemberAccess', object: node, property };
+            }
+            else if (this.match(TokenType.LPAREN)) {
+                                const args = this.parseArgumentList();
+                this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
+                node = { type: 'CallExpression', callee: node, arguments: args };
+            }
+            else {
+                break;
+            }
+        }
+        return node;
+    }
+    parsePrimary() {
+                if (this.match(TokenType.TRUE)) {
+            return { type: 'Literal', value: true };
+        }
+        if (this.match(TokenType.FALSE)) {
+            return { type: 'Literal', value: false };
+        }
+        if (this.match(TokenType.NULL)) {
+            return { type: 'Literal', value: null };
+        }
+        if (this.match(TokenType.UNDEFINED)) {
+            return { type: 'Literal', value: undefined };
+        }
+        if (this.match(TokenType.NUMBER)) {
+            return { type: 'Literal', value: parseFloat(this.previous().value) };
+        }
+        if (this.match(TokenType.STRING)) {
+            return { type: 'Literal', value: this.previous().value };
+        }
+                if (this.match(TokenType.LBRACKET)) {
+            const elements = this.parseArrayElements();
+            this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
+            return { type: 'ArrayLiteral', elements };
+        }
+                if (this.match(TokenType.LBRACE)) {
+            const properties = this.parseObjectProperties();
+            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
+            return { type: 'ObjectLiteral', properties };
+        }
+                if (this.match(TokenType.IDENTIFIER)) {
+            return { type: 'Identifier', name: this.previous().value };
+        }
+                if (this.match(TokenType.LPAREN)) {
+            const expr = this.parseExpression();
+            this.consume(TokenType.RPAREN, 'Expected ")" after expression');
+            return expr;
+        }
+        throw new ExpressionParserError(`Unexpected token: ${this.peek().value}`, this.peek().position, this.expression);
+    }
+    parseArgumentList() {
+        const args = [];
+        if (!this.check(TokenType.RPAREN)) {
+            do {
+                args.push(this.parseExpression());
+            } while (this.match(TokenType.COMMA));
+        }
+        return args;
+    }
+    parseArrayElements() {
+        const elements = [];
+        if (!this.check(TokenType.RBRACKET)) {
+            do {
+                elements.push(this.parseExpression());
+            } while (this.match(TokenType.COMMA));
+        }
+        return elements;
+    }
+    parseObjectProperties() {
+        const properties = [];
+        if (this.check(TokenType.RBRACE)) {
+            return properties;
+        }
+        do {
+                        if (this.check(TokenType.RBRACE))
+                break;
+            let key;
+            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
+                key = this.advance().value;
+            }
+            else {
+                throw new ExpressionParserError(`Expected property name (identifier or string) in object literal, got '${this.peek().value}'`, this.peek().position, this.expression);
+            }
+            this.consume(TokenType.COLON, 'Expected ":" after property name in object literal');
+            const value = this.parseExpression();
+            properties.push({ key, value });
+        } while (this.match(TokenType.COMMA));
+        return properties;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw new ExpressionParserError(message, this.peek().position, this.expression);
+    }
+}
+
+const STRING_SAFE_METHODS = [
+    'charAt',
+    'charCodeAt',
+    'concat',
+    'endsWith',
+    'includes',
+    'indexOf',
+    'lastIndexOf',
+    'match',
+    'padEnd',
+    'padStart',
+    'repeat',
+    'replace',
+    'search',
+    'slice',
+    'split',
+    'startsWith',
+    'substring',
+    'toLowerCase',
+    'toUpperCase',
+    'trim',
+    'trimEnd',
+    'trimStart',
+    'toString',
+];
+const NUMBER_SAFE_METHODS = ['toExponential', 'toFixed', 'toPrecision', 'toString'];
+const ARRAY_SAFE_METHODS = [
+    'concat',
+    'every',
+    'filter',
+    'find',
+    'findIndex',
+    'flat',
+    'flatMap',
+    'includes',
+    'indexOf',
+    'join',
+    'lastIndexOf',
+    'map',
+    'reduce',
+    'reduceRight',
+    'slice',
+    'some',
+    'toString',
+    'entries',
+    'keys',
+    'values',
+];
+const DATE_SAFE_METHODS = [
+    'getDate',
+    'getDay',
+    'getFullYear',
+    'getHours',
+    'getMilliseconds',
+    'getMinutes',
+    'getMonth',
+    'getSeconds',
+    'getTime',
+    'getTimezoneOffset',
+    'getUTCDate',
+    'getUTCDay',
+    'getUTCFullYear',
+    'getUTCHours',
+    'getUTCMilliseconds',
+    'getUTCMinutes',
+    'getUTCMonth',
+    'getUTCSeconds',
+    'toDateString',
+    'toISOString',
+    'toJSON',
+    'toString',
+    'toTimeString',
+    'toUTCString',
+];
+const SAFE_METHODS = {
+    string: new Set(STRING_SAFE_METHODS),
+    number: new Set(NUMBER_SAFE_METHODS),
+    array: new Set(ARRAY_SAFE_METHODS),
+    date: new Set(DATE_SAFE_METHODS),
+};
+const BLOCKED_PROPERTIES = new Set([
+    'constructor',
+    '__proto__',
+    'prototype',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__',
+]);
+class Evaluator {
+    scope;
+    expression;
+    constructor(scope, expression) {
+        this.scope = scope;
+        this.expression = expression;
+    }
+        evaluate(node) {
+        switch (node.type) {
+            case 'Literal':
+                return node.value;
+            case 'Identifier':
+                return this.evaluateIdentifier(node.name);
+            case 'MemberAccess':
+                return this.evaluateMemberAccess(node);
+            case 'ComputedMemberAccess':
+                return this.evaluateComputedMemberAccess(node);
+            case 'BinaryOp':
+                return this.evaluateBinaryOp(node);
+            case 'UnaryOp':
+                return this.evaluateUnaryOp(node);
+            case 'CallExpression':
+                return this.evaluateCallExpression(node);
+            case 'Conditional':
+                return this.evaluate(node.test) ? this.evaluate(node.consequent) : this.evaluate(node.alternate);
+            case 'ArrayLiteral':
+                return this.evaluateArrayLiteral(node);
+            case 'ObjectLiteral':
+                return this.evaluateObjectLiteral(node);
+            case 'ArrowFunction':
+                return this.evaluateArrowFunction(node);
+            default:
+                throw new ExpressionParserError(`Unknown node type: ${node.type}`, 0, this.expression);
+        }
+    }
+    evaluateIdentifier(name) {
+        if (name in this.scope) {
+            return this.scope[name];
+        }
+        return undefined;
+    }
+    evaluateMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+            return undefined;
+        }
+                if (BLOCKED_PROPERTIES.has(node.property)) {
+            throw new ExpressionParserError(`Property "${node.property}" is not accessible for security reasons`, 0, this.expression);
+        }
+                if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[node.property];
+        }
+        return undefined;
+    }
+    evaluateComputedMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+                                    return undefined;
+        }
+        const rawKey = this.evaluate(node.property);
+        if (rawKey === null || rawKey === undefined)
+            return undefined;
+        const key = String(rawKey);
+                        if (BLOCKED_PROPERTIES.has(key)) {
+            throw new ExpressionParserError(`Property "${key}" is not accessible for security reasons`, 0, this.expression);
+        }
+        if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[key];
+        }
+        return undefined;
+    }
+    evaluateBinaryOp(node) {
+                if (node.operator === '&&') {
+            const left = this.evaluate(node.left);
+            return left ? this.evaluate(node.right) : left;
+        }
+        if (node.operator === '||') {
+            const left = this.evaluate(node.left);
+            return left ? left : this.evaluate(node.right);
+        }
+                const left = this.evaluate(node.left);
+        const right = this.evaluate(node.right);
+        switch (node.operator) {
+                        case '+':
+                return left + right;
+            case '-':
+                return left - right;
+            case '*':
+                return left * right;
+            case '/':
+                if (right === 0)
+                    return null;
+                return left / right;
+            case '%':
+                if (right === 0)
+                    return null;
+                return left % right;
+                        case '==':
+                return left == right;
+            case '===':
+                return left === right;
+            case '!=':
+                return left != right;
+            case '!==':
+                return left !== right;
+            case '>':
+                return left > right;
+            case '<':
+                return left < right;
+            case '>=':
+                return left >= right;
+            case '<=':
+                return left <= right;
+            default:
+                throw new ExpressionParserError(`Unknown binary operator: ${node.operator}`, 0, this.expression);
+        }
+    }
+    evaluateUnaryOp(node) {
+        const operand = this.evaluate(node.operand);
+        switch (node.operator) {
+            case '!':
+                return !operand;
+            case '-':
+                return -operand;
+            case '+':
+                return +operand;
+            default:
+                throw new ExpressionParserError(`Unknown unary operator: ${node.operator}`, 0, this.expression);
+        }
+    }
+    evaluateCallExpression(node) {
+                        if (node.callee.type !== 'MemberAccess') {
+            throw new ExpressionParserError('Only method calls are allowed, not arbitrary function calls', 0, this.expression);
+        }
+        const obj = this.evaluate(node.callee.object);
+                                                        if (obj === null || obj === undefined) {
+            return undefined;
+        }
+        const methodName = node.callee.property;
+                if (BLOCKED_PROPERTIES.has(methodName)) {
+            throw new ExpressionParserError(`Property "${methodName}" is not accessible for security reasons`, 0, this.expression);
+        }
+                if (!this.isMethodSafe(obj, methodName)) {
+            throw new ExpressionParserError(`Method "${methodName}" is not allowed for security reasons`, 0, this.expression);
+        }
+                const args = node.arguments.map((arg) => this.evaluate(arg));
+                const method = obj[methodName];
+        if (typeof method === 'function') {
+                        return method.call(obj, ...args);
+        }
+        return undefined;
+    }
+    evaluateArrayLiteral(node) {
+        return node.elements.map((element) => this.evaluate(element));
+    }
+    evaluateObjectLiteral(node) {
+        const result = {};
+        for (const { key, value } of node.properties) {
+            if (BLOCKED_PROPERTIES.has(key)) {
+                throw new ExpressionParserError(`Property "${key}" is not allowed in object literals for security reasons`, 0, this.expression);
+            }
+            result[key] = this.evaluate(value);
+        }
+        return result;
+    }
+    evaluateArrowFunction(node) {
+        const parentScope = this.scope;
+        const expression = this.expression;
+        return (...args) => {
+            const childScope = { ...parentScope };
+            for (let i = 0; i < node.params.length; i++) {
+                childScope[node.params[i]] = args[i];
+            }
+            const childEvaluator = new Evaluator(childScope, expression);
+            return childEvaluator.evaluate(node.body);
+        };
+    }
+    isMethodSafe(obj, methodName) {
+        if (obj === null || obj === undefined) {
+            return false;
+        }
+        const type = Array.isArray(obj) ? 'array' : obj instanceof Date ? 'date' : typeof obj;
+        const safeMethods = SAFE_METHODS[type];
+        if (!safeMethods) {
+            return false;
+        }
+        return safeMethods.has(methodName);
+    }
+}
+
+const MAX_AST_CACHE_SIZE = 1000;
+class LRUCache {
+    cache = new Map();
+    maxSize;
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+                        this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+                if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+                this.cache.set(key, value);
+                if (this.cache.size > this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+const astCache = new LRUCache(MAX_AST_CACHE_SIZE);
+class ExpressionParser {
+        static parse(expression) {
+                const cached = astCache.get(expression);
+        if (cached) {
+            return cached;
+        }
+                const parser = new Parser(expression);
+        const ast = parser.parse();
+                astCache.set(expression, ast);
+        return ast;
+    }
+        static evaluate(expression, scope) {
+        try {
+            const ast = this.parse(expression);
+            const evaluator = new Evaluator(scope, expression);
+            return evaluator.evaluate(ast);
+        }
+        catch (error) {
+            if (error instanceof ExpressionParserError) {
+                throw error;
+            }
+                        throw new ExpressionParserError(`Error evaluating expression: ${error instanceof Error ? error.message : String(error)}`, 0, expression);
+        }
+    }
+        static clearCache() {
+        astCache.clear();
+    }
+        static getCacheStats() {
+        return {
+            size: astCache.size,
+            maxSize: MAX_AST_CACHE_SIZE,
+        };
+    }
+}
+
+function isThenableOrObservable(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.then === 'function' || typeof candidate.subscribe === 'function';
+}
+function evaluateCondition(expression, context) {
+    switch (expression.type) {
+        case 'fieldValue':
+            return evaluateFieldValueCondition(expression, context);
+        case 'javascript':
+            return evaluateJavaScriptExpression(expression, context);
+        case 'custom': {
+                                                const bothSet = expression;
+            const inlineFn = bothSet.fn;
+            const registeredName = bothSet.functionName;
+            if (inlineFn && registeredName) {
+                context.logger.warn('Both "fn" and "functionName" are set on custom condition. Inline "fn" takes precedence; "functionName" is ignored.');
+            }
+            const customFn = inlineFn ?? (registeredName ? context.customFunctions?.[registeredName] : undefined);
+            if (!customFn) {
+                context.logger.error('Custom function not found:', registeredName);
+                return false;
+            }
+            try {
+                const result = customFn(context);
+                if (isThenableOrObservable(result)) {
+                    context.logger.warn(`Custom condition '${registeredName ?? '<inline>'}' returned a Promise or Observable. ` +
+                        `Synchronous conditions must return a value; use an 'async' or 'http' condition type for asynchronous logic. Treating as false.`);
+                    return false;
+                }
+                return !!result;
+            }
+            catch (error) {
+                context.logger.error('Error executing custom function:', registeredName ?? '<inline>', error);
+                return false;
+            }
+        }
+        case 'and':
+            return evaluateAndCondition(expression, context);
+        case 'or':
+            return evaluateOrCondition(expression, context);
+        case 'http':
+            context.logger.warn('HTTP conditions are resolved asynchronously via createHttpConditionLogicFunction(). ' +
+                'When used inside and/or composites, the HTTP result is not available synchronously. Returning false.');
+            return false;
+        case 'async':
+            context.logger.warn('Async Condition - resolved asynchronously via createAsyncConditionLogicFunction(). ' +
+                'When used inside and/or composites, the async result is not available synchronously. Returning false.');
+            return false;
+        default:
+            return false;
+    }
+}
+function evaluateFieldValueCondition(expression, context) {
+        if (!expression.fieldPath)
+        return false;
+                        const fieldValue = hasNestedProperty(context.formValue, expression.fieldPath)
+        ? getNestedValue(context.formValue, expression.fieldPath)
+        : context.rootFormValue
+            ? getNestedValue(context.rootFormValue, expression.fieldPath)
+            : undefined;
+    return compareValues(fieldValue, expression.value, expression.operator);
+}
+function evaluateJavaScriptExpression(expression, context) {
+    try {
+                const result = ExpressionParser.evaluate(expression.expression, context);
+        return !!result;
+    }
+    catch (error) {
+        context.logger.error('Error evaluating JavaScript expression:', expression.expression, error);
+        return false;
+    }
+}
+function evaluateAndCondition(expression, context) {
+    if (expression.conditions.length === 0)
+        return false;
+        return expression.conditions.every((condition) => evaluateCondition(condition, context));
+}
+function evaluateOrCondition(expression, context) {
+    if (expression.conditions.length === 0)
+        return false;
+        return expression.conditions.some((condition) => evaluateCondition(condition, context));
+}
+
+class HttpConditionFunctionCacheService {
+        httpConditionFunctionCache = new Map();
+}
+
+class HttpConditionCache {
+    cache = new Map();
+    maxEntries;
+    constructor(maxEntries = 100) {
+        this.maxEntries = Math.max(1, maxEntries);
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlMs) {
+                while (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, { value, expiresAt: Date.now() + ttlMs });
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const HTTP_CONDITION_CACHE = new InjectionToken('HttpConditionCache');
+
+function resolveHttpRequest(config, context) {
+    let url = config.url;
+    if (config.params) {
+        for (const [key, expression] of Object.entries(config.params)) {
+            const value = ExpressionParser.evaluate(expression, context);
+            if (value == null) {
+                context.logger.debug(`HTTP request suppressed: path param '${key}' resolved to ${String(value)} ` +
+                    `(expression: '${expression}'). The request will not be sent.`);
+                return null;
+            }
+            url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+        }
+    }
+    if (config.queryParams) {
+        const params = new URLSearchParams();
+        for (const [key, expression] of Object.entries(config.queryParams)) {
+            const value = ExpressionParser.evaluate(expression, context);
+            params.set(key, value != null ? String(value) : '');
+        }
+        const queryString = params.toString();
+        if (queryString) {
+            url += (url.includes('?') ? '&' : '?') + queryString;
+        }
+    }
+    const request = {
+        url,
+        method: config.method,
+    };
+    if (config.body) {
+        if (config.evaluateBodyExpressions) {
+            const resolvedBody = {};
+            for (const [key, value] of Object.entries(config.body)) {
+                if (typeof value === 'string') {
+                    resolvedBody[key] = ExpressionParser.evaluate(value, context);
+                }
+                else {
+                    resolvedBody[key] = value;
+                }
+            }
+            request.body = resolvedBody;
+        }
+        else {
+            request.body = config.body;
+        }
+    }
+    if (config.headers) {
+        request.headers = config.headers;
+    }
+    return request;
+}
+
+function extractBoolean(response, responseExpression, pendingValue, logger) {
+    if (responseExpression) {
+        try {
+            const result = ExpressionParser.evaluate(responseExpression, { response });
+            if (typeof result !== 'boolean') {
+                logger.warn(`responseExpression "${responseExpression}" returned non-boolean value:`, result, 'Consider returning a boolean explicitly.');
+            }
+            return !!result;
+        }
+        catch (error) {
+            logger.warn(`Failed to evaluate responseExpression '${responseExpression}':`, error);
+            return pendingValue;
+        }
+    }
+    return !!response;
+}
+function createHttpConditionLogicFunction(condition) {
+    const httpClient = inject(HttpClient, { optional: true });
+    if (!httpClient) {
+        throw new DynamicFormError('HttpClient is required for HTTP conditions. Add provideHttpClient() to your providers.');
+    }
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const functionRegistry = inject(FunctionRegistryService);
+    const injector = inject(Injector);
+    const cache = inject(HTTP_CONDITION_CACHE);
+    const logger = inject(DynamicFormLogger);
+    const cacheService = inject(HttpConditionFunctionCacheService);
+    const pendingValue = condition.pendingValue ?? false;
+    const cacheDurationMs = condition.cacheDurationMs ?? 30000;
+    const debounceMs = condition.debounceMs ?? 300;
+        const cacheKey = stableStringify(condition);
+    const cached = cacheService.httpConditionFunctionCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const fn = createDebouncedResourceLogicFn({
+        pendingValue,
+        debounceMs,
+        injector,
+        resolve: (ctx) => {
+            const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+            const resolved = resolveHttpRequest(condition.http, evaluationContext);
+                                    if (!resolved)
+                return { kind: 'holdPrevious' };
+            const requestKey = stableStringify(resolved);
+            const cachedResult = cache.get(requestKey);
+            if (cachedResult !== undefined)
+                return { kind: 'returnEarly', value: cachedResult };
+            return { kind: 'trigger', key: requestKey, payload: resolved };
+        },
+        buildStream: (request) => {
+            const method = request.method ?? 'GET';
+            const options = {};
+            if (request.body !== undefined)
+                options['body'] = request.body;
+            if (request.headers)
+                options['headers'] = request.headers;
+            return httpClient.request(method, request.url, options).pipe(map((response) => extractBoolean(response, condition.responseExpression, pendingValue, logger)), tap((value) => {
+                const requestKey = stableStringify(request);
+                cache.set(requestKey, value, cacheDurationMs);
+            }), catchError((error) => {
+                logger.warn('HTTP condition request failed:', error);
+                return of(pendingValue);
+            }));
+        },
+    });
+    cacheService.httpConditionFunctionCache.set(cacheKey, fn);
+    return fn;
+}
+
+class LogicFunctionCacheService {
+        logicFunctionCache = new Map();
+        debouncedLogicFunctionCache = new Map();
+        debouncedSignalStore = new Map();
+}
+
+function validateNoNestedHttpConditions(expression) {
+    if (expression.type === 'and' || expression.type === 'or') {
+        for (const sub of expression.conditions) {
+            if (sub.type === 'http' || sub.type === 'async') {
+                const label = sub.type === 'http' ? 'HTTP' : 'Async';
+                throw new DynamicFormError(`${label} conditions cannot be nested inside '${expression.type}' composites. ` +
+                    `Move the ${label} condition to a separate logic entry on the field.`);
+            }
+            validateNoNestedHttpConditions(sub);
+        }
+    }
+}
+function createLogicFunction(expression) {
+        if (expression?.type === 'async') {
+        return createAsyncConditionLogicFunction(expression);
+    }
+        if (expression?.type === 'http') {
+        return createHttpConditionLogicFunction(expression);
+    }
+        if (expression) {
+        validateNoNestedHttpConditions(expression);
+    }
+        const functionRegistry = inject(FunctionRegistryService);
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const cacheService = inject(LogicFunctionCacheService);
+        const cacheKey = stableStringify(expression);
+        const cached = cacheService.logicFunctionCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const fn = (ctx) => {
+                        const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+        return evaluateCondition(expression, evaluationContext);
+    };
+        cacheService.logicFunctionCache.set(cacheKey, fn);
+    return fn;
+}
+function createDebouncedLogicFunction(expression, debounceMs) {
+        if (expression?.type === 'async') {
+        return createAsyncConditionLogicFunction(expression);
+    }
+        if (expression?.type === 'http') {
+        return createHttpConditionLogicFunction(expression);
+    }
+        if (expression) {
+        validateNoNestedHttpConditions(expression);
+    }
+        const functionRegistry = inject(FunctionRegistryService);
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const injector = inject(Injector);
+    const cacheService = inject(LogicFunctionCacheService);
+        const cacheKey = `${stableStringify(expression)}:${debounceMs}`;
+        const cached = cacheService.debouncedLogicFunctionCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const fn = (ctx) => {
+        const contextKey = safeReadPathKeys(ctx).join('.');
+        let signalPair = cacheService.debouncedSignalStore.get(contextKey);
+        if (!signalPair) {
+                        const immediateValue = signal(false, ...(ngDevMode ? [{ debugName: "immediateValue" }] : /* istanbul ignore next */ []));
+                                                const debouncedValue = untracked(() => {
+                const immediateValue$ = toObservable(immediateValue, { injector }).pipe(debounceTime(debounceMs), distinctUntilChanged(), startWith(false));
+                return toSignal(immediateValue$, { injector, initialValue: false });
+            });
+            signalPair = { immediateValue, debouncedValue };
+            cacheService.debouncedSignalStore.set(contextKey, signalPair);
+        }
+                const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+                const result = evaluateCondition(expression, evaluationContext);
+                        const { immediateValue, debouncedValue } = signalPair;
+        untracked(() => {
+            if (immediateValue() !== result) {
+                immediateValue.set(result);
+            }
+        });
+                return debouncedValue() ?? false;
+    };
+        cacheService.debouncedLogicFunctionCache.set(cacheKey, fn);
+    return fn;
+}
+
+function getArrayLength(arrayFieldTree) {
+    const value = arrayFieldTree().value();
+    return Array.isArray(value) ? value.length : 0;
+}
+function toReadonlyFieldTree(field) {
+    const state = field();
+    return {
+        value: state.value,
+        valid: state.valid,
+        invalid: state.invalid,
+        touched: state.touched,
+        dirty: state.dirty,
+        required: state.required,
+        disabled: state.disabled,
+        hidden: state.hidden,
+        errors: state.errors,
+    };
+}
+function writeToFieldValue(value, next, logger) {
+    const candidate = value;
+    if (typeof candidate.set !== 'function') {
+        logger?.warn('writeToFieldValue: FieldState.value is not a WritableSignal — Signal Forms contract changed.');
+        return false;
+    }
+    candidate.set(next);
+    return true;
+}
+const READONLY_FIELD_TREE_CACHE = new InjectionToken('READONLY_FIELD_TREE_CACHE', {
+    providedIn: 'root',
+    factory: () => new WeakMap(),
+});
+function toReadonlyFieldTreeCached(cache, field) {
+    const key = field;
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const view = toReadonlyFieldTree(field);
+    cache.set(key, view);
+    return view;
+}
+
+function evaluateHttpValidationResponse(response, mapping, logger) {
+    const scope = { response };
+    try {
+        const result = ExpressionParser.evaluate(mapping.validWhen, scope);
+        if (typeof result !== 'boolean') {
+            logger.warn(`validWhen expression "${mapping.validWhen}" returned non-boolean value:`, result, 'Expected true or false.');
+        }
+        if (result === true) {
+            return null;
+        }
+        const error = { kind: mapping.errorKind };
+        if (mapping.errorParams) {
+            for (const [key, expression] of Object.entries(mapping.errorParams)) {
+                try {
+                    error[key] = ExpressionParser.evaluate(expression, scope);
+                }
+                catch (err) {
+                    logger.warn(`Error evaluating errorParam "${key}":`, expression, err);
+                }
+            }
+        }
+        return error;
+    }
+    catch (err) {
+        logger.warn('Error evaluating validWhen expression:', mapping.validWhen, err);
+        return { kind: mapping.errorKind };
+    }
+}
+
+const noOpLogger = {
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: () => { },
+};
+const DEFAULT_SUBMIT_BUTTON_OPTIONS = {
+    disableWhenInvalid: true,
+    disableWhileSubmitting: true,
+};
+const DEFAULT_NEXT_BUTTON_OPTIONS = {
+    disableWhenPageInvalid: true,
+    disableWhileSubmitting: true,
+};
+function evaluateFormStateCondition(condition, ctx) {
+    const form = ctx.form();
+    switch (condition) {
+        case 'formInvalid':
+            return !form.valid();
+        case 'formSubmitting':
+            return form.submitting();
+        case 'pageInvalid':
+            return ctx.currentPageValid ? !ctx.currentPageValid() : false;
+        default:
+            return false;
+    }
+}
+function evaluateLogicCondition(condition, ctx) {
+        if (typeof condition === 'boolean') {
+        return condition;
+    }
+        if (isFormStateCondition(condition)) {
+        return evaluateFormStateCondition(condition, ctx);
+    }
+        const formValue = (ctx.formValue ?? ctx.form().value());
+    const evaluationContext = {
+        fieldValue: undefined,
+        formValue,
+        fieldPath: '',
+        logger: ctx.logger ?? noOpLogger,
+    };
+    return evaluateCondition(condition, evaluationContext);
+}
+function hasFieldLevelDisabledCondition(fieldLogic, ctx) {
+    if (!fieldLogic || fieldLogic.length === 0) {
+        return false;
+    }
+    return fieldLogic.filter((logic) => logic.type === 'disabled').some((logic) => evaluateLogicCondition(logic.condition, ctx));
+}
+function hasCustomLogicOfType(fieldLogic, logicType) {
+    if (!fieldLogic || fieldLogic.length === 0) {
+        return false;
+    }
+    return fieldLogic.some((logic) => logic.type === logicType);
+}
+function evaluateLogicOfType(fieldLogic, logicType, ctx) {
+    if (!fieldLogic || fieldLogic.length === 0) {
+        return false;
+    }
+    const buttonCtx = {
+        form: ctx.form,
+        formValue: ctx.formValue,
+        logger: ctx.logger,
+    };
+    return fieldLogic.filter((logic) => logic.type === logicType).some((logic) => evaluateLogicCondition(logic.condition, buttonCtx));
+}
+function resolveSubmitButtonDisabled(ctx) {
+    return computed(() => {
+                if (ctx.explicitlyDisabled) {
+            return true;
+        }
+                if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
+            return hasFieldLevelDisabledCondition(ctx.fieldLogic, ctx);
+        }
+                const options = {
+            ...DEFAULT_SUBMIT_BUTTON_OPTIONS,
+            ...ctx.formOptions?.submitButton,
+        };
+        const form = ctx.form();
+        if (options.disableWhenInvalid && !form.valid()) {
+            return true;
+        }
+        if (options.disableWhileSubmitting && form.submitting()) {
+            return true;
+        }
+        return false;
+    });
+}
+function resolveNextButtonDisabled(ctx) {
+    return computed(() => {
+                if (ctx.explicitlyDisabled) {
+            return true;
+        }
+                if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
+            return hasFieldLevelDisabledCondition(ctx.fieldLogic, ctx);
+        }
+                const options = {
+            ...DEFAULT_NEXT_BUTTON_OPTIONS,
+            ...ctx.formOptions?.nextButton,
+        };
+        const form = ctx.form();
+        if (options.disableWhenPageInvalid && ctx.currentPageValid && !ctx.currentPageValid()) {
+            return true;
+        }
+        if (options.disableWhileSubmitting && form.submitting()) {
+            return true;
+        }
+        return false;
+    });
+}
+function evaluateNonFieldHidden(ctx) {
+        if (ctx.explicitValue) {
+        return true;
+    }
+        if (hasCustomLogicOfType(ctx.fieldLogic, 'hidden')) {
+        return evaluateLogicOfType(ctx.fieldLogic, 'hidden', {
+            form: ctx.form,
+            formValue: ctx.formValue,
+            logger: ctx.logger,
+        });
+    }
+        return false;
+}
+function resolveNonFieldHidden(ctx) {
+    return computed(() => evaluateNonFieldHidden(ctx));
+}
+function evaluateNonFieldDisabled(ctx) {
+        if (ctx.explicitValue) {
+        return true;
+    }
+        if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
+        return evaluateLogicOfType(ctx.fieldLogic, 'disabled', {
+            form: ctx.form,
+            formValue: ctx.formValue,
+            logger: ctx.logger,
+        });
+    }
+        return false;
+}
+function resolveNonFieldDisabled(ctx) {
+    return computed(() => evaluateNonFieldDisabled(ctx));
+}
+
+function isFunctionHttpValidator(config) {
+    const c = config;
+    return typeof c.functionName === 'string' || (c.fn !== null && typeof c.fn === 'object');
+}
+
+class DynamicValueFunctionCacheService {
+        dynamicValueFunctionCache = new Map();
+}
+
+function createDynamicValueFunction(expression) {
+            const fieldContextRegistry = inject(FieldContextRegistryService);
+    const logger = inject(DynamicFormLogger);
+    const cacheService = inject(DynamicValueFunctionCacheService);
+        const cached = cacheService.dynamicValueFunctionCache.get(expression);
+    if (cached) {
+        return cached;
+    }
+    const fn = (ctx) => {
+                const evaluationContext = fieldContextRegistry.createEvaluationContext(ctx);
+        try {
+                        return ExpressionParser.evaluate(expression, evaluationContext);
+        }
+        catch (error) {
+            logger.error('Error evaluating dynamic expression:', expression, error);
+            return undefined;
+        }
+    };
+        cacheService.dynamicValueFunctionCache.set(expression, fn);
+    return fn;
+}
+
+function applyEmailValidator(path) {
+    email(path);
+}
+function applyMinValidator(path, value, expression) {
+    if (expression) {
+        min(path, createDynamicValueFunction(expression));
+    }
+    else {
+        min(path, value);
+    }
+}
+function applyMaxValidator(path, value, expression) {
+    if (expression) {
+        max(path, createDynamicValueFunction(expression));
+    }
+    else {
+        max(path, value);
+    }
+}
+function applyMinLengthValidator(path, value, expression) {
+    if (expression) {
+        minLength(path, createDynamicValueFunction(expression));
+    }
+    else {
+        minLength(path, value);
+    }
+}
+function applyMaxLengthValidator(path, value, expression) {
+    if (expression) {
+        maxLength(path, createDynamicValueFunction(expression));
+    }
+    else {
+        maxLength(path, value);
+    }
+}
+function applyPatternValidator(path, value, expression) {
+    if (expression) {
+        pattern(path, createDynamicValueFunction(expression));
+    }
+    else {
+        pattern(path, value);
+    }
+}
+function createConditionalLogic(when) {
+    return when ? createLogicFunction(when) : undefined;
+}
+function applyValidator(config, fieldPath) {
+    const path = fieldPath;
+    if (!isResourceBasedValidator(config) && (isCrossFieldBuiltInValidator(config) || hasCrossFieldWhenCondition(config))) {
+        return;
+    }
+    switch (config.type) {
+        case 'required':
+            if (config.when) {
+                required(path, { when: createLogicFunction(config.when) });
+            }
+            else {
+                required(path);
+            }
+            break;
+        case 'email':
+            applyEmailValidator(fieldPath);
+            break;
+        case 'min':
+            if (typeof config.value === 'number') {
+                applyMinValidator(fieldPath, config.value, config.expression);
+            }
+            break;
+        case 'max':
+            if (typeof config.value === 'number') {
+                applyMaxValidator(fieldPath, config.value, config.expression);
+            }
+            break;
+        case 'minLength':
+            if (typeof config.value === 'number') {
+                applyMinLengthValidator(fieldPath, config.value, config.expression);
+            }
+            break;
+        case 'maxLength':
+            if (typeof config.value === 'number') {
+                applyMaxLengthValidator(fieldPath, config.value, config.expression);
+            }
+            break;
+        case 'pattern':
+            if (config.value instanceof RegExp || typeof config.value === 'string') {
+                let regexPattern;
+                if (typeof config.value === 'string') {
+                    try {
+                        regexPattern = new RegExp(config.value);
+                    }
+                    catch (e) {
+                        throw new DynamicFormError(`Invalid regex pattern in validator: '${config.value}' — ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                else {
+                    regexPattern = config.value;
+                }
+                applyPatternValidator(fieldPath, regexPattern, config.expression);
+            }
+            break;
+        case 'custom':
+            applyCustomValidator(config, path);
+            break;
+        case 'async':
+            applyAsyncValidator(config, path);
+            break;
+        case 'http':
+            applyUnifiedHttpValidator(config, path);
+            break;
+    }
+}
+function applyCustomValidator(config, fieldPath) {
+    if (isCrossFieldValidator(config)) {
+        return;
+    }
+    let validatorFn;
+    if (config.expression) {
+        validatorFn = createExpressionValidator(config);
+    }
+    else if (config.fn || config.functionName) {
+        validatorFn = createFunctionValidator(config);
+    }
+    else {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Custom validator must have one of "expression", "functionName", or "fn"');
+        return;
+    }
+    const whenLogic = createConditionalLogic(config.when);
+    validate(fieldPath, (ctx) => {
+        if (whenLogic && !whenLogic(ctx))
+            return null;
+        return validatorFn(ctx);
+    });
+}
+function createFunctionValidator(config) {
+    const logger = inject(DynamicFormLogger);
+    if (config.fn && config.functionName) {
+        logger.warn('Both "fn" and "functionName" are set on custom validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    if (config.fn) {
+        const inlineFn = config.fn;
+        return (ctx) => inlineFn(ctx, config.params);
+    }
+    const functionName = config.functionName;
+    if (!functionName) {
+        logger.warn('Custom validator missing functionName');
+        return () => null;
+    }
+    const registry = inject(FunctionRegistryService);
+    const validatorFn = registry.getValidator(functionName);
+    if (!validatorFn) {
+        throw new DynamicFormError(`Custom validator "${functionName}" not found. Register it with customFnConfig.validators.`);
+    }
+    return (ctx) => validatorFn(ctx, config.params);
+}
+function createExpressionValidator(config) {
+    const logger = inject(DynamicFormLogger);
+    const expression = config.expression;
+    if (!expression) {
+        logger.warn('Custom validator missing expression');
+        return () => null;
+    }
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const functionRegistry = inject(FunctionRegistryService);
+    return (ctx) => {
+        try {
+            const evaluationContext = fieldContextRegistry.createEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+            const result = ExpressionParser.evaluate(expression, evaluationContext);
+            if (result) {
+                return null;
+            }
+            const kind = config.kind || 'custom';
+            const validationError = { kind };
+            if (config.errorParams) {
+                Object.entries(config.errorParams).forEach(([key, expression]) => {
+                    try {
+                        validationError[key] = ExpressionParser.evaluate(expression, evaluationContext);
+                    }
+                    catch (err) {
+                        logger.warn(`Error evaluating errorParam "${key}":`, expression, err);
+                    }
+                });
+            }
+            return validationError;
+        }
+        catch (error) {
+                                    logger.error('Error evaluating custom validator expression:', expression, error);
+            return { kind: config.kind || 'custom' };
+        }
+    };
+}
+function applyAsyncValidator(config, fieldPath) {
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on async validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let validatorConfig;
+    if (config.fn) {
+        validatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        validatorConfig = registry.getAsyncValidator(config.functionName);
+        if (!validatorConfig) {
+            throw new DynamicFormError(`Async validator "${config.functionName}" not found. Register it with customFnConfig.asyncValidators.`);
+        }
+    }
+    else {
+                throw new DynamicFormError('Async validator requires one of "functionName" or "fn".');
+    }
+    const whenLogic = createConditionalLogic(config.when);
+    const asyncOptions = {
+        params: (ctx) => {
+            if (whenLogic && !whenLogic(ctx))
+                return undefined;
+            return validatorConfig.params(ctx, config.params);
+        },
+        factory: validatorConfig.factory,
+        onSuccess: validatorConfig.onSuccess,
+        onError: validatorConfig.onError,
+    };
+    validateAsync(fieldPath, asyncOptions);
+}
+function applyUnifiedHttpValidator(config, fieldPath) {
+    if (isFunctionHttpValidator(config)) {
+        applyFunctionHttpValidator(config, fieldPath);
+        return;
+    }
+                const declarative = config;
+    if (!declarative.http || !declarative.responseMapping) {
+        throw new DynamicFormError('HTTP validator requires one of "functionName" / "fn" (function-based) or "http" + "responseMapping" (declarative).');
+    }
+    applyDeclarativeHttpValidator(config, fieldPath);
+}
+function applyFunctionHttpValidator(config, fieldPath) {
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on HTTP validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let httpValidatorConfig;
+    if (config.fn) {
+        httpValidatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        httpValidatorConfig = registry.getHttpValidator(config.functionName);
+        if (!httpValidatorConfig) {
+            throw new DynamicFormError(`HTTP validator "${config.functionName}" not found. Register it with customFnConfig.httpValidators.`);
+        }
+    }
+    else {
+                throw new DynamicFormError('HTTP validator requires one of "functionName" or "fn".');
+    }
+    const whenLogic = createConditionalLogic(config.when);
+    const httpOptions = {
+        request: (ctx) => {
+            if (whenLogic && !whenLogic(ctx))
+                return undefined;
+            return httpValidatorConfig.request(ctx, config.params);
+        },
+        onSuccess: httpValidatorConfig.onSuccess,
+        onError: httpValidatorConfig.onError,
+    };
+    validateHttp(fieldPath, httpOptions);
+}
+function applyDeclarativeHttpValidator(config, fieldPath) {
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const functionRegistry = inject(FunctionRegistryService);
+    const logger = inject(DynamicFormLogger);
+    const whenLogic = createConditionalLogic(config.when);
+    validateHttp(fieldPath, {
+        request: (ctx) => {
+            if (whenLogic && !whenLogic(ctx))
+                return undefined;
+                                                const evalCtx = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
+                        return resolveHttpRequest(config.http, evalCtx) ?? undefined;
+        },
+        onSuccess: (response) => {
+            return evaluateHttpValidationResponse(response, config.responseMapping, logger);
+        },
+        onError: (error) => {
+            logger.warn('HTTP validator request failed:', error);
+            return { kind: config.responseMapping.errorKind };
+        },
+    });
+}
+function applyValidators(configs, fieldPath) {
+    configs.forEach((config) => applyValidator(config, fieldPath));
+}
+
+function isCheckedField(field) {
+    return field.type === 'checkbox' || field.type === 'toggle';
+}
+
+function isValueField(field) {
+                return 'value' in field || 'nullable' in field;
+}
+
+function isArrayField(field) {
+    return field.type === 'array' && 'fields' in field && Array.isArray(field.fields);
+}
+function isSimplifiedArrayField(field) {
+    return field.type === 'array' && 'template' in field;
+}
+
+function isContainerTypedField(field) {
+    return (field.type === 'container' &&
+        'wrappers' in field &&
+        'fields' in field &&
+        Array.isArray(field.wrappers) &&
+        Array.isArray(field.fields));
+}
+
+function isGroupField(field) {
+    return field.type === 'group' && 'fields' in field;
+}
+
+function isHiddenField(field) {
+    return field.type === 'hidden';
+}
+
+function isRowField(field) {
+    return field.type === 'row' && 'fields' in field && Array.isArray(field.fields);
+}
+
+function isPageField(field) {
+    return field.type === 'page' && 'fields' in field && Array.isArray(field.fields);
+}
+function validatePageNesting(pageField) {
+    return !hasNestedPages(pageField.fields);
+}
+function isContainerWithFields$1(field) {
+    return ((isRowField(field) || isGroupField(field) || isContainerTypedField(field)) &&
+        'fields' in field &&
+        Array.isArray(field.fields));
+}
+function hasNestedPages(fields) {
+    for (const field of fields) {
+        if (isPageField(field)) {
+            return true;
+        }
+                if (isContainerWithFields$1(field)) {
+            if (hasNestedPages(field.fields)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+class ComponentInitializedEvent {
+    componentType;
+    componentId;
+    type = 'component-initialized';
+    constructor(componentType, componentId) {
+        this.componentType = componentType;
+        this.componentId = componentId;
+    }
+}
+
+const EMIT_FORM_VALUE_ON_EVENTS = new InjectionToken('EMIT_FORM_VALUE_ON_EVENTS', {
+    providedIn: 'root',
+    factory: () => false,
+});
+
+class NoopLogger {
+    debug() {
+            }
+    info() {
+            }
+    warn() {
+            }
+    error() {
+            }
+}
+
+function safeInjectToken(token, defaultValue) {
+    try {
+        return inject(token, { optional: true }) ?? defaultValue;
+    }
+    catch {
+        return defaultValue;
+    }
+}
+function safeInjectClass(token, defaultValue) {
+    try {
+        return inject(token, { optional: true }) ?? defaultValue;
+    }
+    catch {
+        return defaultValue;
+    }
+}
+function attachFormValue(event, formValue) {
+    const prototype = Object.getPrototypeOf(event);
+    return Object.assign(Object.create(prototype), event, { formValue });
+}
+const FALLBACK_LOGGER = new NoopLogger();
+class EventBus {
+    pipeline$ = new Subject();
+    globalEmitFormValue = safeInjectToken(EMIT_FORM_VALUE_ON_EVENTS, false);
+    rootFormRegistry = safeInjectClass(RootFormRegistryService, null);
+    formOptions = safeInjectToken(FORM_OPTIONS, null);
+    logger = safeInjectToken(DynamicFormLogger, FALLBACK_LOGGER);
+    events$ = this.pipeline$.asObservable();
+    dispatch(eventOrConstructor, ...args) {
+        if (typeof eventOrConstructor !== 'function' && 'type' in eventOrConstructor) {
+            this.emit(eventOrConstructor);
+        }
+        else {
+            this.emit(new eventOrConstructor(...args));
+        }
+    }
+        emitInstance(event) {
+        this.emit(event);
+    }
+        emit(event) {
+        if (this.shouldEmitFormValue()) {
+            const formValue = this.rootFormRegistry?.formValue();
+                                    if (formValue && Object.keys(formValue).length > 0) {
+                this.safeEmit(attachFormValue(event, formValue));
+                return;
+            }
+        }
+        this.safeEmit(event);
+    }
+        safeEmit(event) {
+        try {
+            this.pipeline$.next(event);
+        }
+        catch (err) {
+            this.logger.error('Exception in EventBus subscriber during dispatch', err);
+        }
+    }
+        shouldEmitFormValue() {
+        const formLevelSetting = this.formOptions?.()?.emitFormValueOnEvents;
+        return formLevelSetting ?? this.globalEmitFormValue;
+    }
+        on(eventType) {
+        if (Array.isArray(eventType)) {
+            return this.pipeline$.pipe(filter((event) => eventType.includes(event.type)));
+        }
+        return this.pipeline$.pipe(filter((event) => event.type === eventType));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus, decorators: [{
+            type: Injectable
+        }] });
+
+function hasFormValue(event) {
+    return 'formValue' in event && event.formValue !== undefined;
+}
+
+function resolveTokens(args, context) {
+    return args.map((arg) => {
+                if (typeof arg !== 'string') {
+            return arg;
+        }
+                switch (arg) {
+            case '$key':
+                return context.key;
+            case '$index':
+                return context.index;
+            case '$arrayKey':
+                return context.arrayKey;
+            case '$template':
+                return context.template;
+            case 'formValue':
+                return context.formValue;
+            default:
+                                return arg;
+        }
+    });
+}
+
+function applyHiddenLogic(inputs, fieldDef, rootFormRegistry) {
+    const rootForm = rootFormRegistry.rootForm();
+    if (rootForm && (fieldDef.hidden === true || fieldDef.logic?.some((l) => l.type === 'hidden'))) {
+                        inputs['hidden'] = evaluateNonFieldHidden({
+            form: rootForm,
+            fieldLogic: fieldDef.logic,
+            explicitValue: fieldDef.hidden,
+            formValue: rootFormRegistry.formValue(),
+        });
+    }
+}
+
+function getGridClassString(fieldDef) {
+    const col = fieldDef.col;
+    if (typeof col === 'number' && Number.isInteger(col) && col > 0 && col <= 12) {
+        return `df-col-${col}`;
+    }
+    return '';
+}
+function buildClassName(fieldDef) {
+    const gridClass = getGridClassString(fieldDef);
+    const userClass = fieldDef.className;
+    const classes = [];
+    if (gridClass) {
+        classes.push(gridClass);
+    }
+    if (userClass) {
+        classes.push(userClass);
+    }
+    return classes.length > 0 ? classes.join(' ') : undefined;
+}
+
+function arrayFieldMapper(fieldDef) {
+    const rootFormRegistry = inject(RootFormRegistryService);
+    const className = buildClassName(fieldDef);
+    return computed(() => {
+        const inputs = {
+            key: fieldDef.key,
+            field: fieldDef,
+            ...(className !== undefined && { className }),
+        };
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        return inputs;
+    });
+}
+
+function buildBaseInputs(fieldDef, defaultProps) {
+    const { key, label, className, tabIndex, props, meta, addons } = fieldDef;
+    const inputs = {};
+                        inputs['key'] = key;
+    if (label !== undefined) {
+        inputs['label'] = label;
+    }
+        const gridClassString = getGridClassString(fieldDef);
+    const allClasses = [];
+    if (gridClassString) {
+        allClasses.push(gridClassString);
+    }
+    if (className) {
+        allClasses.push(className);
+    }
+    if (allClasses.length > 0) {
+        inputs['className'] = allClasses.join(' ');
+    }
+    if (tabIndex !== undefined) {
+        inputs['tabIndex'] = tabIndex;
+    }
+            const fieldProps = props;
+    const mergedProps = fieldProps !== undefined || defaultProps !== undefined ? { ...(defaultProps ?? {}), ...(fieldProps ?? {}) } : undefined;
+    if (mergedProps !== undefined) {
+        inputs['props'] = mergedProps;
+    }
+    if (meta !== undefined) {
+        inputs['meta'] = meta;
+    }
+                    if (addons !== undefined) {
+        inputs['addons'] = addons;
+    }
+    return inputs;
+}
+function baseFieldMapper(fieldDef) {
+            return computed(() => buildBaseInputs(fieldDef));
+}
+
+function containerFieldMapper(fieldDef) {
+    const rootFormRegistry = inject(RootFormRegistryService);
+    const className = buildClassName(fieldDef);
+    return computed(() => {
+                                                        const containerField = { ...fieldDef, wrappers: undefined, skipAutoWrappers: undefined, skipDefaultWrappers: undefined };
+        const inputs = {
+            key: fieldDef.key,
+            field: containerField,
+            ...(className !== undefined && { className }),
+        };
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        return inputs;
+    });
+}
+
+function groupFieldMapper(fieldDef) {
+    const rootFormRegistry = inject(RootFormRegistryService);
+    const className = buildClassName(fieldDef);
+    return computed(() => {
+        const inputs = {
+            key: fieldDef.key,
+            field: fieldDef,
+            ...(className !== undefined && { className }),
+        };
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        return inputs;
+    });
+}
+
+const ROW_WRAPPERS = [{ type: 'row' }];
+function rowFieldMapper(fieldDef) {
+    const rootFormRegistry = inject(RootFormRegistryService);
+    const className = buildClassName(fieldDef);
+    return computed(() => {
+                                                        const containerField = { ...fieldDef, type: 'container', wrappers: ROW_WRAPPERS };
+        const inputs = {
+            key: fieldDef.key,
+            field: containerField,
+            ...(className !== undefined && { className }),
+        };
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        return inputs;
+    });
+}
+
+function pageFieldMapper(fieldDef) {
+    const className = buildClassName(fieldDef);
+        return computed(() => ({
+        key: fieldDef.key,
+        field: fieldDef,
+        ...(className !== undefined && { className }),
+    }));
+}
+
+function textFieldMapper(fieldDef) {
+    const rootFormRegistry = inject(RootFormRegistryService);
+    const defaultProps = inject(DEFAULT_PROPS);
+        return computed(() => {
+        const baseInputs = buildBaseInputs(fieldDef, defaultProps());
+        const inputs = { ...baseInputs };
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        return inputs;
+    });
+}
+
+function isFieldBoundContext(ctx) {
+    return ctx.form !== null;
+}
+
+const ADDON_KIND_REGISTRY = new InjectionToken('ADDON_KIND_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+
+const DF_FIELD_TEMPLATES = new InjectionToken('DF_FIELD_TEMPLATES');
+
+const FIELD_REGISTRY = new InjectionToken('FIELD_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+function getFieldValueHandling(fieldType, registry) {
+    const definition = registry.get(fieldType);
+    return definition?.valueHandling ?? 'include';
+}
+
+function isWrapperTypeDefinition(value) {
+    return typeof value === 'object' && value !== null && 'wrapperName' in value;
+}
+const WRAPPER_REGISTRY = new InjectionToken('WRAPPER_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+const WRAPPER_COMPONENT_CACHE = new InjectionToken('WRAPPER_COMPONENT_CACHE', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+const WRAPPER_AUTO_ASSOCIATIONS = new InjectionToken('WRAPPER_AUTO_ASSOCIATIONS', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+
+function isContainerWithFields(field) {
+    return ((field.type === 'row' || field.type === 'group' || field.type === 'page' || field.type === 'container') &&
+        'fields' in field &&
+        Array.isArray(field.fields));
+}
+function isPagedForm(fields) {
+    if (!fields || fields.length === 0) {
+        return false;
+    }
+    return fields.every((field) => isPageField(field));
+}
+function isNonPagedForm(fields) {
+    if (!fields || fields.length === 0) {
+        return true;     }
+    return !hasAnyPageFields(fields);
+}
+function detectFormMode(fields) {
+    if (!fields || fields.length === 0) {
+        return {
+            mode: 'non-paged',
+            isValid: true,
+            errors: [],
+        };
+    }
+    const hasPageFields = fields.some((field) => isPageField(field));
+    const allPagesAtRoot = fields.every((field) => isPageField(field));
+    const hasNestedPages = hasNestedPageFields(fields);
+        if (hasPageFields) {
+        const errors = [];
+                if (!allPagesAtRoot) {
+            errors.push('Mixed page and non-page fields at root level. In paged forms, ALL root-level fields must be of type "page".');
+        }
+                if (hasNestedPages) {
+            errors.push('Page fields cannot contain nested page fields at any level.');
+        }
+        return {
+            mode: 'paged',
+            isValid: errors.length === 0,
+            errors,
+        };
+    }
+    else {
+                const errors = [];
+                if (hasAnyPageFields(fields)) {
+            errors.push('Page fields are not allowed in non-paged forms.');
+        }
+        return {
+            mode: 'non-paged',
+            isValid: errors.length === 0,
+            errors,
+        };
+    }
+}
+function hasAnyPageFields(fields) {
+    for (const field of fields) {
+        if (isPageField(field)) {
+            return true;
+        }
+                if (!isPageField(field) && isContainerWithFields(field)) {
+            if (hasAnyPageFields(field.fields)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function hasNestedPageFields(fields) {
+    for (const field of fields) {
+                if (isPageField(field) && isContainerWithFields(field)) {
+            if (hasAnyPageFields(field.fields)) {
+                return true;
+            }
+        }
+                if (!isPageField(field) && isContainerWithFields(field)) {
+            if (hasNestedPageFields(field.fields)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isValidPagedForm(fields) {
+    const result = detectFormMode(fields);
+    return result.mode === 'paged' && result.isValid;
+}
+function isValidNonPagedForm(fields) {
+    const result = detectFormMode(fields);
+    return result.mode === 'non-paged' && result.isValid;
+}
+
+function hasChildFields(field) {
+    return 'fields' in field && field.fields != null;
+}
+const CONTAINER_TYPES = new Set(['page', 'row', 'group', 'array', 'container']);
+function isContainerField(field) {
+    return CONTAINER_TYPES.has(field.type);
+}
+function isLeafField(field) {
+    return !isContainerField(field);
+}
+function isValueBearingField(field) {
+    return 'value' in field;
+}
+function isDisplayOnlyField(field) {
+    return field.type === 'text' || isContainerField(field);
+}
+
+
+class DynamicTextPipe {
+    injector = inject(Injector);
+        transform(value) {
+        if (isObservable(value)) {
+            return value;
+        }
+        if (isSignal(value)) {
+            return toObservable(value, { injector: this.injector });
+        }
+        return of(value || '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, isStandalone: true, name: "dynamicText" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dynamicText',
+                }]
+        }] });
+
+function applyMetaToElement(element, meta, previouslyApplied) {
+    const newApplied = new Set();
+        for (const attr of previouslyApplied) {
+        if (!meta || !(attr in meta) || meta[attr] === undefined) {
+            element.removeAttribute(attr);
+        }
+    }
+    if (!meta)
+        return newApplied;
+        for (const [key, value] of Object.entries(meta)) {
+        if (value === undefined || value === null)
+            continue;
+        element.setAttribute(key, String(value));
+        newApplied.add(key);
+    }
+    return newApplied;
+}
+
+function dynamicTextToObservable(value, injector) {
+    if (value === undefined) {
+        return of('');
+    }
+    if (isObservable(value)) {
+        return value;
+    }
+    if (isSignal(value)) {
+        return toObservable(value, { injector });
+    }
+    return of(String(value));
+}
+
+function resolveDynamicValue(value, fallback, injector) {
+    if (value === undefined) {
+        return computed(() => fallback);
+    }
+    if (isSignal(value)) {
+        return value;
+    }
+    if (isObservable(value)) {
+        return toSignal(value, { initialValue: fallback, injector });
+    }
+        return computed(() => value);
+}
+
+const INITIALIZATION_TIMEOUT_MS = new InjectionToken('INITIALIZATION_TIMEOUT_MS', {
+    providedIn: 'root',
+    factory: () => 10_000,
+});
+function createInitializationTracker(eventBus, expectedCount) {
+    return eventBus.on('component-initialized').pipe(scan((count) => count + 1, 0), map$1((currentCount) => currentCount >= expectedCount), filter$1((isComplete) => isComplete));
+}
+function setupInitializationTracking(options) {
+    const { eventBus, totalComponentsCount, injector, componentId } = options;
+    const timeoutMs = injector.get(INITIALIZATION_TIMEOUT_MS);
+    const logger = injector.get(DynamicFormLogger);
+    return toObservable(totalComponentsCount, { injector }).pipe(take(1), switchMap((count) => {
+        const tracking$ = count === 1
+            ?                 eventBus.on('component-initialized').pipe(filter$1((event) => event.componentType === 'dynamic-form' && event.componentId === componentId), map$1(() => true), take(1))
+            : createInitializationTracker(eventBus, count);
+                return tracking$.pipe(timeout(timeoutMs), catchError$1((error) => {
+            if (error instanceof TimeoutError) {
+                logger.warn(`Initialization timed out after ${timeoutMs}ms. ` +
+                    `Expected ${count} component(s) to initialize but not all reported in time. ` +
+                    'This may indicate a container component threw during initialization. ' +
+                    'Emitting (initialized) as best-effort.');
+                                return of(true);
+            }
+            return throwError(() => error);
+        }));
+    }), shareReplay({ bufferSize: 1, refCount: false }));
+}
+
+function interpolateParams(message, error) {
+    let result = message;
+    const params = extractErrorParams(error);
+    Object.entries(params).forEach(([key, value]) => {
+        const placeholder = new RegExp(`{{\\s*${key}\\s*}}`, 'g');
+        result = result.replace(placeholder, safeToString(value));
+    });
+    return result;
+}
+function safeToString(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+        if (value instanceof RegExp) {
+        return value.toString();
+    }
+        if (value instanceof Date) {
+        return value.toISOString();
+    }
+        if (Array.isArray(value)) {
+        return value.join(', ');
+    }
+        try {
+                if (typeof value === 'object' && value.toString !== Object.prototype.toString) {
+            return value.toString();
+        }
+                return JSON.stringify(value);
+    }
+    catch {
+                return '[object]';
+    }
+}
+function extractErrorParams(error) {
+    const params = {};
+        if ('min' in error)
+        params.min = error.min;
+    if ('max' in error)
+        params.max = error.max;
+    if ('pattern' in error)
+        params.pattern = error.pattern;
+    if ('actual' in error)
+        params.actual = error.actual;
+    if ('expected' in error)
+        params.expected = error.expected;
+                    if ('requiredLength' in error) {
+        params.requiredLength = error.requiredLength;
+    }
+    else if ('minLength' in error) {
+                params.requiredLength = error.minLength;
+        params.minLength = error.minLength;
+    }
+    else if ('maxLength' in error) {
+                params.requiredLength = error.maxLength;
+        params.maxLength = error.maxLength;
+    }
+    if ('actualLength' in error)
+        params.actualLength = error.actualLength;
+            Object.keys(error).forEach((key) => {
+        if (key !== 'kind' && !(key in params)) {
+            params[key] = error[key];
+        }
+    });
+    return params;
+}
+
+function isEqual(a, b) {
+    return isEqualInternal(a, b, new WeakMap(), new WeakMap());
+}
+function isEqualInternal(a, b, seenA, seenB) {
+        if (a === b)
+        return true;
+        if (typeof a === 'number' && typeof b === 'number') {
+        return Object.is(a, b);
+    }
+        if (a == null || b == null)
+        return false;
+        if (typeof a !== typeof b)
+        return false;
+        if (typeof a !== 'object') {
+        return Object.is(a, b);
+    }
+        const objA = a;
+    const objB = b;
+        if (seenA.has(objA) || seenB.has(objB)) {
+                return seenA.get(objA) === objB && seenB.get(objB) === objA;
+    }
+        seenA.set(objA, objB);
+    seenB.set(objB, objA);
+        if (objA.constructor !== objB.constructor)
+        return false;
+        if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+        if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+        if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size)
+            return false;
+        for (const [key, value] of a) {
+            if (!b.has(key) || !isEqualInternal(value, b.get(key), seenA, seenB)) {
+                return false;
+            }
+        }
+        return true;
+    }
+        if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size)
+            return false;
+        for (const value of a) {
+            if (!b.has(value)) {
+                                                if (typeof value === 'object' && value !== null) {
+                    let found = false;
+                    for (const bValue of b) {
+                        if (typeof bValue === 'object' && bValue !== null && isEqualInternal(value, bValue, seenA, seenB)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found)
+                        return false;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+        if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((item, index) => isEqualInternal(item, b[index], seenA, seenB));
+    }
+        const recordA = a;
+    const recordB = b;
+        const keysA = [...Object.keys(recordA), ...Object.getOwnPropertySymbols(recordA)];
+    const keysB = [...Object.keys(recordB), ...Object.getOwnPropertySymbols(recordB)];
+    if (keysA.length !== keysB.length)
+        return false;
+        const keySetB = new Set(keysB);
+    return keysA.every((key) => keySetB.has(key) && isEqualInternal(recordA[key], recordB[key], seenA, seenB));
+}
+function omit(obj, keys) {
+    const result = { ...obj };
+    keys.forEach((key) => delete result[key]);
+    return result;
+}
+function keyBy(array, key) {
+    return array.reduce((acc, item) => {
+        acc[String(item[key])] = item;
+        return acc;
+    }, {});
+}
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        acc[key] = fn(value, key);
+        return acc;
+    }, {});
+}
+function deepMergeDefaults(defaults, value) {
+    if (value == null)
+        return { ...defaults };
+    const result = { ...defaults };
+    for (const key of Object.keys(value)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
+        const incoming = value[key];
+        const existing = result[key];
+        if (isPlainObject(existing) && isPlainObject(incoming)) {
+            result[key] = deepMergeDefaults(existing, incoming);
+        }
+        else if (Array.isArray(existing) && Array.isArray(incoming)) {
+            result[key] = mergeArrayDefaults(existing, incoming);
+        }
+        else {
+            result[key] = incoming;
+        }
+    }
+    return result;
+}
+function mergeArrayDefaults(defaults, value) {
+    if (defaults.length !== value.length)
+        return value;
+                if (!value.some((item, i) => isPlainObject(defaults[i]) && isPlainObject(item)))
+        return value;
+    return value.map((item, i) => {
+        const defaultItem = defaults[i];
+        if (isPlainObject(defaultItem) && isPlainObject(item)) {
+            return deepMergeDefaults(defaultItem, item);
+        }
+        return item;
+    });
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+const DEFAULT_MEMOIZE_MAX_SIZE = 100;
+function memoize(fn, resolverOrOptions) {
+    const options = typeof resolverOrOptions === 'function' ? { resolver: resolverOrOptions } : (resolverOrOptions ?? {});
+    const { resolver, maxSize = DEFAULT_MEMOIZE_MAX_SIZE } = options;
+    const cache = new Map();
+    return ((...args) => {
+        const key = resolver ? resolver(...args) : JSON.stringify(args);
+        const cachedValue = cache.get(key);
+        if (cachedValue !== undefined) {
+            cache.delete(key);
+            cache.set(key, cachedValue);
+            return cachedValue;
+        }
+        const result = fn(...args);
+        if (cache.size >= maxSize) {
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                cache.delete(oldestKey);
+            }
+        }
+        cache.set(key, result);
+        return result;
+    });
+}
+function normalizeFieldsArray(fields) {
+    return Array.isArray(fields) ? [...fields] : Object.values(fields);
+}
+function getChangedKeys(previous, current) {
+    const changedKeys = new Set();
+        if (!previous && !current)
+        return changedKeys;
+    if (!previous) {
+        return new Set(Object.keys(current ?? {}));
+    }
+    if (!current) {
+        return new Set(Object.keys(previous));
+    }
+        const allKeys = new Set([...Object.keys(previous), ...Object.keys(current)]);
+        for (const key of allKeys) {
+        const prevValue = previous[key];
+        const currValue = current[key];
+                if (!(key in previous) || !(key in current)) {
+            changedKeys.add(key);
+            continue;
+        }
+                if (!isEqual(prevValue, currValue)) {
+            changedKeys.add(key);
+        }
+    }
+    return changedKeys;
+}
+function assertNever(value) {
+    throw new DynamicFormError(`Unexpected value: ${JSON.stringify(value)}`);
+}
+
+function createWarningTracker() {
+    return { warnedKeys: new Set() };
+}
+
+
+
+export { ADDON_KIND_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectFieldSignalContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
+//# sourceMappingURL=ng-forge-dynamic-forms-internal.mjs.map