@ng-forge/dynamic-forms 1.3.0-next.2 → 1.3.0-next.4

package/fesm2022/ng-forge-dynamic-forms-schema-builder-BvDTzfdM.mjs

@@ -1,570 +0,0 @@
-import { inject } from '@angular/core';
-import { validateStandardSchema, schema, required, disabled, readonly, hidden, applyEach, applyWhenValue, applyWhen, apply, email, minLength, maxLength, pattern, min, max } from '@angular/forms/signals';
-import { isStateLogicConfig, isDerivationLogicConfig, isFormStateCondition, DynamicFormError, createFormStateLogicFunction, createDebouncedLogicFunction, createLogicFunction, ExpressionParser, DynamicFormLogger, applyValidator, isPageField, isRowField, isGenericContainerField, isGroupField, isArrayField, getFieldValueHandling, hasChildFields, normalizeFieldsArray } from '@ng-forge/dynamic-forms/internal';
-import { q as DEV_MODE, S as SchemaRegistryService, h as getNormalizedArrayMetadata, V as VALIDATION_EXECUTION_DEFAULTS, k as getFieldDefaultValue } from './ng-forge-dynamic-forms-ng-forge-dynamic-forms-CXQe_5td.mjs';
-import { D as DEFAULT_DEBOUNCE_MS } from './ng-forge-dynamic-forms-debounce-C9F4v1Ke.mjs';
-import { isStandardSchemaMarker } from '@ng-forge/dynamic-forms/schema';
-
-function applyFormLevelSchema(path, formLevelSchema) {
-    if (isStandardSchemaMarker(formLevelSchema)) {
-                                validateStandardSchema(path, formLevelSchema.schema);
-    }
-    else if (typeof formLevelSchema === 'function') {
-                                formLevelSchema(path);
-    }
-}
-function createFormLevelSchema(formLevelSchema) {
-    return schema((path) => {
-        applyFormLevelSchema(path, formLevelSchema);
-    });
-}
-
-function getConfigTrigger(config) {
-    if (!isStateLogicConfig(config)) {
-        return 'onChange';
-    }
-    return config.trigger ?? 'onChange';
-}
-function getConfigDebounceMs(config) {
-    if (!isStateLogicConfig(config)) {
-        return undefined;
-    }
-        if (config.trigger === 'debounced') {
-        return config.debounceMs;
-    }
-    return undefined;
-}
-function applyLogic(config, fieldPath) {
-        if (isDerivationLogicConfig(config))
-        return;
-        if (!isStateLogicConfig(config)) {
-        if (DEV_MODE) {
-            console.warn(`[Dynamic Forms] Unrecognized logic config type '${config.type}' in applyLogic. ` +
-                'This config will be ignored. If this is a new logic type, ensure it is handled explicitly.');
-        }
-        return;
-    }
-    const path = fieldPath;
-    const trigger = getConfigTrigger(config);
-    const debounceMs = getConfigDebounceMs(config) ?? DEFAULT_DEBOUNCE_MS;
-    if (typeof config.condition === 'boolean') {
-        applyLogicFn(config.type, path, () => config.condition);
-        return;
-    }
-        if (isFormStateCondition(config.condition)) {
-                        if (config.condition === 'formInvalid' || config.condition === 'pageInvalid') {
-            const reason = config.condition === 'formInvalid'
-                ? `it would create a validation cycle against the form's own validity`
-                : `a value field has no page context for it to resolve against`;
-            throw new DynamicFormError(`The '${config.condition}' form-state condition is not supported on value-field logic because ${reason}. ` +
-                `Use 'formSubmitting', or apply this condition to a button or container instead.`);
-        }
-        applyLogicFn(config.type, path, createFormStateLogicFunction(config.condition));
-        return;
-    }
-        const logicFn = trigger === 'debounced'
-        ? createDebouncedLogicFunction(config.condition, debounceMs)
-        : createLogicFunction(config.condition);
-    applyLogicFn(config.type, path, logicFn);
-}
-function applyLogicFn(type, path, logicFn) {
-    switch (type) {
-        case 'hidden':
-            hidden(path, logicFn);
-            break;
-        case 'readonly':
-            readonly(path, logicFn);
-            break;
-        case 'disabled':
-            disabled(path, logicFn);
-            break;
-        case 'required':
-            required(path, { when: logicFn });
-            break;
-        default: {
-            const _exhaustive = type;
-            throw new DynamicFormError(`Unhandled state logic type: ${_exhaustive}`);
-        }
-    }
-}
-function applyMultipleLogic(configs, fieldPath) {
-    configs.forEach((config) => applyLogic(config, fieldPath));
-}
-
-function createTypePredicateFunction(predicate, logger) {
-    return (value) => {
-        try {
-                        const result = ExpressionParser.evaluate(predicate, { value });
-            return Boolean(result);
-        }
-        catch (error) {
-            logger.error('Error evaluating type predicate:', predicate, error);
-            return false;
-        }
-    };
-}
-
-function applySchema(config, fieldPath) {
-    const logger = inject(DynamicFormLogger);
-    const schemaRegistry = inject(SchemaRegistryService);
-    const schema = schemaRegistry.resolveSchema(config.schema);
-    if (!schema) {
-        const availableSchemas = Array.from(schemaRegistry.getAllSchemas().keys()).join(', ') || '<none>';
-        logger.error(`Schema not found: '${config.schema}'. ` +
-            `Available schemas: ${availableSchemas}. ` +
-            `Ensure the schema is registered in your schema registry.`);
-        return;
-    }
-    const schemaFn = createSchemaFunction(schema, logger);
-        const path = fieldPath;
-    switch (config.type) {
-        case 'apply':
-            apply(path, schemaFn);
-            break;
-        case 'applyWhen':
-            if (config.condition) {
-                const conditionFn = createLogicFunction(config.condition);
-                applyWhen(path, conditionFn, schemaFn);
-            }
-            break;
-        case 'applyWhenValue':
-            if (config.typePredicate) {
-                const predicate = createTypePredicateFunction(config.typePredicate, logger);
-                applyWhenValue(path, predicate, schemaFn);
-            }
-            break;
-        case 'applyEach':
-            applyEach(path, schemaFn);
-            break;
-    }
-}
-function createSchemaFunction(schema, logger) {
-    return (path) => {
-                schema.validators?.forEach((validatorConfig) => {
-            applyValidator(validatorConfig, path);
-        });
-                schema.logic?.forEach((logicConfig) => {
-            applyLogic(logicConfig, path);
-        });
-                schema.subSchemas?.forEach((subSchemaConfig) => {
-            applySchema(subSchemaConfig, path);
-        });
-    };
-}
-
-function combineAncestorHiddenLogics(logics) {
-    if (logics.length === 0)
-        return undefined;
-    if (logics.length === 1)
-        return logics[0];
-    return (ctx) => logics.some((fn) => fn(ctx));
-}
-function resolveFieldOwnContext(fieldDef, parentContext) {
-    if (fieldDef.validateWhenHidden === undefined)
-        return parentContext;
-    if (fieldDef.validateWhenHidden === parentContext.validateWhenHidden)
-        return parentContext;
-    return {
-        ...parentContext,
-        validateWhenHidden: fieldDef.validateWhenHidden,
-    };
-}
-function resolveDescendantContext(fieldDef, ownContext) {
-    let ancestorAlwaysHidden = ownContext.ancestorAlwaysHidden;
-    let ancestorHiddenLogics = ownContext.ancestorHiddenLogics;
-    let mutated = false;
-                let ancestorRequired = ownContext.ancestorRequired;
-    if (fieldDef.required !== undefined && fieldDef.required !== ancestorRequired) {
-        ancestorRequired = fieldDef.required;
-        mutated = true;
-    }
-    if (fieldDef.hidden === true && !ancestorAlwaysHidden) {
-        ancestorAlwaysHidden = true;
-        mutated = true;
-    }
-    if (fieldDef.logic) {
-        for (const logic of fieldDef.logic) {
-            if (!isStateLogicConfig(logic) || logic.type !== 'hidden')
-                continue;
-            const condition = logic.condition;
-            if (condition === true) {
-                if (!ancestorAlwaysHidden) {
-                    ancestorAlwaysHidden = true;
-                    mutated = true;
-                }
-                continue;
-            }
-            if (condition === false)
-                continue;
-                                    if (typeof condition === 'string')
-                continue;
-                                    const fn = createLogicFunction(condition);
-            ancestorHiddenLogics = ancestorHiddenLogics.length === 0 ? [fn] : [...ancestorHiddenLogics, fn];
-            mutated = true;
-        }
-    }
-    if (!mutated)
-        return ownContext;
-    return {
-        validateWhenHidden: ownContext.validateWhenHidden,
-        ancestorAlwaysHidden,
-        ancestorHiddenLogics,
-        ancestorRequired,
-    };
-}
-
-const DEFAULT_FIELD_TREE_MAPPING_CONTEXT = {
-    validateWhenHidden: false,
-    ancestorAlwaysHidden: false,
-    ancestorHiddenLogics: [],
-};
-function applyStringValidators(path, config) {
-    if (config.email) {
-        email(path);
-    }
-    if (config.minLength !== undefined) {
-        minLength(path, config.minLength);
-    }
-    if (config.maxLength !== undefined) {
-        maxLength(path, config.maxLength);
-    }
-    if (config.pattern) {
-        let regex;
-        if (typeof config.pattern === 'string') {
-            try {
-                regex = new RegExp(config.pattern);
-            }
-            catch (e) {
-                throw new DynamicFormError(`Invalid regex pattern: '${config.pattern}' — ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-        else {
-            regex = config.pattern;
-        }
-        pattern(path, regex);
-    }
-}
-function applyNumberValidators(path, config) {
-    if (config.min !== undefined) {
-        min(path, config.min);
-    }
-    if (config.max !== undefined) {
-        max(path, config.max);
-    }
-}
-function getStringValidationConfig(fieldDef) {
-    if (!fieldDef.email && fieldDef.minLength === undefined && fieldDef.maxLength === undefined && !fieldDef.pattern) {
-        return undefined;
-    }
-    return {
-        email: fieldDef.email,
-        minLength: fieldDef.minLength,
-        maxLength: fieldDef.maxLength,
-        pattern: fieldDef.pattern,
-    };
-}
-function getNumberValidationConfig(fieldDef) {
-    const minVal = fieldDef.min ?? fieldDef.minValue;
-    const maxVal = fieldDef.max ?? fieldDef.maxValue;
-    if (minVal === undefined && maxVal === undefined) {
-        return undefined;
-    }
-    return { min: minVal, max: maxVal };
-}
-function hasValidationRules(fieldDef, context) {
-    const declaresRequiredLogic = fieldDef.logic?.some(isValidationStateLogic) ?? false;
-    const required = fieldDef.required ?? (declaresRequiredLogic ? false : context.ancestorRequired);
-    return (required === true ||
-        declaresRequiredLogic ||
-        getStringValidationConfig(fieldDef) !== undefined ||
-        getNumberValidationConfig(fieldDef) !== undefined ||
-        (fieldDef.validators?.length ?? 0) > 0);
-}
-function mapFieldToForm(fieldDef, fieldPath, inheritedContext = DEFAULT_FIELD_TREE_MAPPING_CONTEXT) {
-    const ownContext = resolveFieldOwnContext(fieldDef, inheritedContext);
-                if (isPageField(fieldDef) || isRowField(fieldDef) || isGenericContainerField(fieldDef)) {
-        const descendantContext = resolveDescendantContext(fieldDef, ownContext);
-        mapContainerChildren(fieldDef.fields, fieldPath, descendantContext);
-        return;
-    }
-                    if (isGroupField(fieldDef)) {
-        const descendantContext = resolveDescendantContext(fieldDef, ownContext);
-        applyContainerValidators(fieldDef, fieldPath, descendantContext);
-        mapContainerChildren(fieldDef.fields, fieldPath, descendantContext);
-        return;
-    }
-        if (isArrayField(fieldDef)) {
-        const descendantContext = resolveDescendantContext(fieldDef, ownContext);
-        mapArrayFieldToForm(fieldDef, fieldPath, descendantContext);
-        return;
-    }
-                mapLeafField(fieldDef, fieldPath, ownContext);
-}
-function mapContainerChildren(fields, parentPath, inheritedContext) {
-    if (!fields)
-        return;
-    const pathRecord = parentPath;
-    for (const field of fields) {
-        if (isPageField(field) || isRowField(field) || isGenericContainerField(field)) {
-                                    const layoutOwn = resolveFieldOwnContext(field, inheritedContext);
-            const layoutDescendant = resolveDescendantContext(field, layoutOwn);
-            mapContainerChildren(field.fields, parentPath, layoutDescendant);
-            continue;
-        }
-        if (!field.key)
-            continue;
-        const childPath = pathRecord[field.key];
-        if (childPath) {
-            mapFieldToForm(field, childPath, inheritedContext);
-        }
-    }
-}
-function isValidationStateLogic(config) {
-    return isStateLogicConfig(config) && config.type === 'required';
-}
-function mapLeafField(fieldDef, fieldPath, context) {
-    const validationField = fieldDef;
-    const path = fieldPath;
-                applyFieldState(fieldDef, path);
-    if (validationField.logic) {
-        for (const config of validationField.logic) {
-            if (!isValidationStateLogic(config)) {
-                applyLogic(config, fieldPath);
-            }
-        }
-    }
-    if (validationField.schemas) {
-        for (const config of validationField.schemas) {
-            applySchema(config, fieldPath);
-        }
-    }
-    if (!hasValidationRules(validationField, context)) {
-        return;
-    }
-        const applyValidation = (validationPath) => {
-        applySimpleValidationRules(validationField, validationPath, context);
-        if (validationField.validators) {
-            for (const config of validationField.validators) {
-                applyValidator(config, validationPath);
-            }
-        }
-        if (validationField.logic) {
-            for (const config of validationField.logic) {
-                if (isValidationStateLogic(config)) {
-                    applyLogic(config, validationPath);
-                }
-            }
-        }
-    };
-    applyHiddenGatedValidation(path, context, applyValidation);
-}
-function applyHiddenGatedValidation(path, context, apply) {
-    if (context.validateWhenHidden) {
-        apply(path);
-        return;
-    }
-            if (context.ancestorAlwaysHidden) {
-        return;
-    }
-                            const ancestorHiddenLogic = combineAncestorHiddenLogics(context.ancestorHiddenLogics);
-    applyWhen(path, (ctx) => {
-        if (ctx.state.hidden())
-            return false;
-        if (ancestorHiddenLogic && ancestorHiddenLogic(ctx))
-            return false;
-        return true;
-    }, schema((subPath) => apply(subPath)));
-}
-function applyContainerValidators(fieldDef, fieldPath, context) {
-    const validators = fieldDef.validators;
-    if (!validators || validators.length === 0)
-        return;
-    applyHiddenGatedValidation(fieldPath, context, (validationPath) => {
-        for (const config of validators) {
-            applyValidator(config, validationPath, 'tree');
-        }
-    });
-}
-function applySimpleValidationRules(fieldDef, path, context) {
-                const declaresRequiredLogic = fieldDef.logic?.some(isValidationStateLogic) ?? false;
-    if (fieldDef.required ?? (declaresRequiredLogic ? false : context.ancestorRequired)) {
-        required(path);
-    }
-        const stringConfig = getStringValidationConfig(fieldDef);
-    if (stringConfig) {
-        applyStringValidators(path, stringConfig);
-    }
-        const numberConfig = getNumberValidationConfig(fieldDef);
-    if (numberConfig) {
-        applyNumberValidators(path, numberConfig);
-    }
-}
-function applyFieldState(fieldDef, path) {
-    if (fieldDef.disabled) {
-        disabled(path);
-    }
-    if (fieldDef.readonly) {
-        readonly(path);
-    }
-    if (fieldDef.hidden) {
-        hidden(path, () => true);
-    }
-}
-function mapArrayFieldToForm(arrayField, fieldPath, context) {
-    if (!isArrayField(arrayField)) {
-        return;
-    }
-        if (arrayField.minLength !== undefined) {
-        minLength(fieldPath, arrayField.minLength);
-    }
-    if (arrayField.maxLength !== undefined) {
-        maxLength(fieldPath, arrayField.maxLength);
-    }
-    applyContainerValidators(arrayField, fieldPath, context);
-        let itemDefinitions = arrayField.fields;
-                    if (!itemDefinitions || itemDefinitions.length === 0) {
-        const metadataTemplate = getNormalizedArrayMetadata(arrayField)?.template;
-        if (metadataTemplate) {
-            itemDefinitions = [
-                Array.isArray(metadataTemplate) ? [...metadataTemplate] : metadataTemplate,
-            ];
-        }
-    }
-            if (!itemDefinitions || itemDefinitions.length === 0) {
-        const emptyItemSchema = schema(() => {
-                    });
-        applyEach(fieldPath, emptyItemSchema);
-        return;
-    }
-        let hasPrimitiveItems = false;
-    const allObjectFields = [];
-    for (const itemDef of itemDefinitions) {
-        if (Array.isArray(itemDef)) {
-                        collectFieldsFromObjectItem(itemDef, allObjectFields);
-        }
-        else if (isPageField(itemDef) ||
-            isRowField(itemDef) ||
-            isGenericContainerField(itemDef)) {
-                                                collectFieldsFromObjectItem([itemDef], allObjectFields);
-        }
-        else {
-                        hasPrimitiveItems = true;
-        }
-    }
-        if (hasPrimitiveItems && allObjectFields.length === 0) {
-        const primitiveItemSchema = schema(() => {
-                    });
-        applyEach(fieldPath, primitiveItemSchema);
-        return;
-    }
-            const itemSchema = schema((itemPath) => {
-        const pathRecord = itemPath;
-                for (const templateField of allObjectFields) {
-            if (isRowField(templateField) || isPageField(templateField) || isGenericContainerField(templateField)) {
-                                const layoutOwn = resolveFieldOwnContext(templateField, context);
-                const layoutDescendant = resolveDescendantContext(templateField, layoutOwn);
-                mapContainerChildren(templateField.fields, itemPath, layoutDescendant);
-            }
-            else if (isGroupField(templateField)) {
-                const groupKey = templateField.key;
-                if (groupKey) {
-                                        const groupPath = pathRecord[groupKey];
-                    if (groupPath) {
-                        mapFieldToForm(templateField, groupPath, context);
-                    }
-                }
-                else {
-                                        const groupOwn = resolveFieldOwnContext(templateField, context);
-                    mapContainerChildren(templateField.fields, itemPath, resolveDescendantContext(templateField, groupOwn));
-                }
-            }
-            else {
-                                const fieldKey = templateField.key;
-                if (fieldKey) {
-                    const fieldPathForKey = pathRecord[fieldKey];
-                    if (fieldPathForKey) {
-                        mapFieldToForm(templateField, fieldPathForKey, context);
-                    }
-                }
-            }
-        }
-    });
-    applyEach(fieldPath, itemSchema);
-}
-function collectFieldsFromObjectItem(itemFields, allFields) {
-    const seenKeys = new Set(allFields.map((f) => f.key).filter(Boolean));
-    for (const field of itemFields) {
-                if (isRowField(field) || isPageField(field) || isGenericContainerField(field)) {
-                        const containerKey = `__container_${field.type}_${JSON.stringify(field.fields?.map((f) => f.key))}`;
-            if (!seenKeys.has(containerKey)) {
-                seenKeys.add(containerKey);
-                allFields.push(field);
-            }
-        }
-        else {
-            const key = field.key;
-            if (key && !seenKeys.has(key)) {
-                seenKeys.add(key);
-                allFields.push(field);
-            }
-        }
-    }
-}
-
-function createSchemaFromFields(fields, registry, options = {}) {
-            const validationExecutionDefaults = inject(VALIDATION_EXECUTION_DEFAULTS);
-    const { formLevelSchema } = options;
-    const rootContext = {
-        validateWhenHidden: options.validateWhenHidden ?? validationExecutionDefaults.validateWhenHidden,
-        ancestorAlwaysHidden: false,
-        ancestorHiddenLogics: [],
-    };
-    return schema((path) => {
-        for (const fieldDef of fields) {
-            const valueHandling = getFieldValueHandling(fieldDef.type, registry);
-                        if (valueHandling === 'exclude') {
-                                continue;
-            }
-            if (valueHandling === 'flatten' && hasChildFields(fieldDef)) {
-                                                                const flattenedOwn = resolveFieldOwnContext(fieldDef, rootContext);
-                const flattenedContext = resolveDescendantContext(fieldDef, flattenedOwn);
-                for (const childField of normalizeFieldsArray(fieldDef.fields)) {
-                    if (!childField.key)
-                        continue;
-                    const childPath = path[childField.key];
-                    if (childPath) {
-                        mapFieldToForm(childField, childPath, flattenedContext);
-                    }
-                }
-                continue;
-            }
-                        const fieldPath = path[fieldDef.key];
-            if (!fieldPath) {
-                continue;
-            }
-                                                mapFieldToForm(fieldDef, fieldPath, rootContext);
-        }
-                if (formLevelSchema) {
-            applyFormLevelSchema(path, formLevelSchema);
-        }
-    });
-}
-function fieldsToDefaultValues(fields, registry) {
-    const defaultValues = {};
-    for (const field of fields) {
-        if (!field.key)
-            continue;
-                const valueHandling = getFieldValueHandling(field.type, registry);
-        if (valueHandling === 'flatten') {
-            continue;
-        }
-        const value = getFieldDefaultValue(field, registry);
-        if (value !== undefined) {
-            defaultValues[field.key] = value;
-        }
-    }
-    return defaultValues;
-}
-
-export { createFormLevelSchema as a, createSchemaFromFields as c };
-//# sourceMappingURL=ng-forge-dynamic-forms-schema-builder-BvDTzfdM.mjs.map

package/fesm2022/ng-forge-dynamic-forms-schema-builder-BvDTzfdM.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ng-forge-dynamic-forms-schema-builder-BvDTzfdM.mjs","mappings":";;;;;;;AAmBM;AACJ;wBAIG;;AACI;;;AAMT;AASM;AACJ;AACE;AACF;AACF;;ACzBA;AACE;AACE;;AAEF;AACF;AAGA;AACE;AACE;;IAGF;;;AAGA;AACF;AAEM;;;IAKJ;;AAEI;AAEI;;;;;AAOR;;AAGA;AACE;;;IAKF;gBAGE;AACE;AAEI;;;AAIA;;AAGN;;;IAKF;;AAGI;;AAGN;AAEA;;AAEI;AACE;;AAEF;AACE;;AAEF;AACE;;AAEF;;;;;AAKE;;;AAGN;AAEM;AACJ;AACF;;ACtGM;;AAEF;YAEE;AACA;;;;AAGA;;AAEJ;AACF;;ACNM;AACJ;AACA;;;;AAKE;AAEI;AACA;;;;;AAUN;AACE;AACE;;AAGF;AACE;;AAEE;;;AAIJ;AACE;;AAEE;;;AAIJ;AACE;;;AAGN;AAGM;;;AAIA;AACF;;AAIE;AACF;;AAIE;AACF;AACF;AACF;;AC3BM;AACJ;AAAyB;AACzB;AAAyB;AACzB;AACF;AAYM;AAIJ;AAA+C;AAC/C;AAAsE;;AAEpE;;;AAGJ;AAUM;AAIJ;AACA;;YAMA;AACA;AACE;;;;;;;AASF;AACE;;;AAGE;AAEA;;;;;;;;;;;wBAgBA;;;;;AAMJ;AAAc;;;;;;;AAQhB;;ACvGA;AACE;AACA;AACA;;AA0BF;AACE;;;AAGA;AACE;;AAEF;AACE;;AAEF;AACE;AACA;AACE;;;;;;;;AAMA;;AAEF;;AAEJ;AAMA;AACE;AACE;;AAEF;AACE;;AAEJ;AAMA;;AAEI;;;;;;;;AAQJ;AAOA;;;;AAKI;;;AAGJ;AAGM;AACJ;AACA;;;AAKE;AACA;;AAGJ;AAWM;;YAUJ;;;;;gBAUA;;AAEE;;;;IAMF;;AAEE;;;YAOF;AACF;AAGA;AAKE;;;AAIA;AACE;;;;;;;;;;AAaE;;;AAGN;AAOA;;AAEA;AASA;;;YAOE;AAEA;AACE;AACE;AACE;;;;AAKN;AACE;AACE;;;;;;IASJ;AACE;AAEA;AACE;AACE;;;AAIJ;AACE;AACE;AACE;;;;AAIR;AAEA;AACF;AAGA;AAKE;;;;QAOA;;;;AAWA;AAGI;AAAwB;AACxB;AAAqD;AACrD;AACF;AAGJ;AAMA;AACE;AACA;;;AAGE;AACE;;AAEJ;AACF;AAMA;YAIE;AACA;;;IAKA;;AAEE;;IAIF;;AAEE;;AAEJ;AAGA;AACE;;;AAIA;;;AAIA;;;AAGF;AAGA;AACE;;;IAKA;AACE;;AAEF;AACE;;AAGF;IAGA;;;;AASI;AACE;;;;;AAQJ;YAEA;AACA;;;;;AAQF;AACE;YAEE;;;;AAIA;oCAKA;;;;;;;AASF;YAEA;AACA;;;QAMF;;QAIE;AACE;;;;;AAKO;AACL;;oBAGE;;AAEE;;;;;AAKF;;;;gBAIF;;AAEE;;AAEE;;;;;AAKV;AAEA;AACF;AAOA;;AAGE;QAEE;YAEE;;AAEE;AACA;;;;AAGF;;AAEE;AACA;;;;AAIR;;AChfM;QAOJ;AAEA;AACA;AACE;AACA;AACA;;AAGF;AACE;;YAIE;;;;;;;;;;;AAgBM;;;;;;;;;oCAgBN;;;AAKA;;AAEJ;AACF;AAGM;;AAGJ;;;;AAKE;;;;AAKA;AACE;;;AAIJ;AACF","names":[],"ignoreList":[],"sources":["../../../../packages/dynamic-forms/src/lib/core/form-schema-merger.ts","../../../../packages/dynamic-forms/src/lib/core/logic/logic-applicator.ts","../../../../packages/dynamic-forms/src/lib/core/values/type-predicate-factory.ts","../../../../packages/dynamic-forms/src/lib/core/schema-application.ts","../../../../packages/dynamic-forms/src/lib/core/field-tree-mapping-context.ts","../../../../packages/dynamic-forms/src/lib/core/form-mapping.ts","../../../../packages/dynamic-forms/src/lib/core/schema-builder.ts"],"sourcesContent":["import { schema, Schema, SchemaPathTree, validateStandardSchema } from '@angular/forms/signals';\n// Import from secondary entry point - this is correct for ng-packagr's entry point architecture\n// (different from importing internal barrel files which should be avoided)\nimport { isStandardSchemaMarker, type FormSchema } from '@ng-forge/dynamic-forms/schema';\n\n/**\n * Applies a form-level schema validation to a schema path.\n * Supports both Standard Schema (Zod, Valibot, ArkType) and raw Angular schema callbacks.\n *\n * @typeParam TModel - The form value type\n * @param path - The schema path to validate (from Angular's schema callback)\n * @param formLevelSchema - Form-level schema (Standard Schema marker or Angular callback)\n * @remarks\n * Type assertions are required due to Angular's complex generic constraints:\n * - `validateStandardSchema` uses `IgnoreUnknownProperties<TSchema>` to accommodate Zod's strict types\n * - `SchemaPathTree` includes `SchemaPath` via conditional types that TypeScript can't narrow\n * These assertions are safe because the path originates from Angular's schema() function.\n * @internal\n */\nexport function applyFormLevelSchema<TModel>(path: SchemaPathTree<TModel>, formLevelSchema: FormSchema<TModel>): void {\n  if (isStandardSchemaMarker(formLevelSchema)) {\n    // Standard Schema (Zod, Valibot, ArkType, etc.)\n    // Cast via Parameters: validateStandardSchema's IgnoreUnknownProperties<TSchema> creates type incompatibility\n    // that TypeScript cannot resolve. The cast is safe as path comes from Angular's schema() callback.\n    (validateStandardSchema as (...args: unknown[]) => void)(path, formLevelSchema.schema);\n  } else if (typeof formLevelSchema === 'function') {\n    // Angular schema callback - execute directly with the path\n    // Cast via Function: AngularSchemaCallback expects intersection type SchemaPath & SchemaPathTree.\n    // SchemaPathTree structurally includes SchemaPath, so this is safe at runtime.\n    (formLevelSchema as (path: unknown) => void)(path);\n  }\n}\n\n/**\n * Creates a schema from only form-level schema (when no field-level schema exists).\n *\n * @typeParam TModel - The form value type\n * @param formLevelSchema - Form-level Standard Schema\n * @returns Schema that applies form-level validation\n */\nexport function createFormLevelSchema<TModel>(formLevelSchema: FormSchema<TModel>): Schema<TModel> {\n  return schema<TModel>((path) => {\n    applyFormLevelSchema(path, formLevelSchema);\n  });\n}\n","import { disabled, hidden, readonly, required, LogicFn } from '@angular/forms/signals';\nimport { DEV_MODE } from '../../utils/dev-mode';\nimport type { SchemaPath, SchemaPathTree } from '@angular/forms/signals';\nimport {\n  LogicConfig,\n  isStateLogicConfig,\n  isDerivationLogicConfig,\n  isFormStateCondition,\n  LogicTrigger,\n  type StateLogicType,\n} from '@ng-forge/dynamic-forms/internal';\nimport { ConditionalExpression } from '@ng-forge/dynamic-forms/internal';\nimport { createLogicFunction, createDebouncedLogicFunction, createFormStateLogicFunction } from '@ng-forge/dynamic-forms/internal';\nimport { DEFAULT_DEBOUNCE_MS } from '../../utils/debounce/debounce';\nimport { DynamicFormError } from '@ng-forge/dynamic-forms/internal';\n\ntype AnyLogicFn<TValue> = LogicFn<TValue, boolean> | (() => boolean);\n\n/** Extracts the trigger from a StateLogicConfig, handling the discriminated union. */\nfunction getConfigTrigger(config: LogicConfig): LogicTrigger {\n  if (!isStateLogicConfig(config)) {\n    return 'onChange';\n  }\n  return config.trigger ?? 'onChange';\n}\n\n/** Extracts debounceMs from a StateLogicConfig if trigger is 'debounced'. */\nfunction getConfigDebounceMs(config: LogicConfig): number | undefined {\n  if (!isStateLogicConfig(config)) {\n    return undefined;\n  }\n  // Type narrowing: debounceMs only exists when trigger is 'debounced'\n  if (config.trigger === 'debounced') {\n    return config.debounceMs;\n  }\n  return undefined;\n}\n\nexport function applyLogic<TValue>(config: LogicConfig, fieldPath: SchemaPath<TValue> | SchemaPathTree<TValue>): void {\n  // Value derivations (including property derivations via targetProperty) are handled by their orchestrators — skip them.\n  if (isDerivationLogicConfig(config)) return;\n\n  // Guard against unrecognized logic types that may be added in the future.\n  if (!isStateLogicConfig(config)) {\n    if (DEV_MODE) {\n      console.warn(\n        `[Dynamic Forms] Unrecognized logic config type '${(config as { type: string }).type}' in applyLogic. ` +\n          'This config will be ignored. If this is a new logic type, ensure it is handled explicitly.',\n      );\n    }\n    return;\n  }\n\n  const path = fieldPath as SchemaPath<TValue>;\n  const trigger = getConfigTrigger(config);\n  const debounceMs = getConfigDebounceMs(config) ?? DEFAULT_DEBOUNCE_MS;\n\n  if (typeof config.condition === 'boolean') {\n    applyLogicFn(config.type, path, () => config.condition as boolean);\n    return;\n  }\n\n  // Form-state conditions read root form state, not the expression evaluator.\n  if (isFormStateCondition(config.condition)) {\n    // formInvalid cycles against the field's own validity; pageInvalid has no leaf page context.\n    // Only formSubmitting (an independent flag) is cycle-free on value fields.\n    if (config.condition === 'formInvalid' || config.condition === 'pageInvalid') {\n      const reason =\n        config.condition === 'formInvalid'\n          ? `it would create a validation cycle against the form's own validity`\n          : `a value field has no page context for it to resolve against`;\n      throw new DynamicFormError(\n        `The '${config.condition}' form-state condition is not supported on value-field logic because ${reason}. ` +\n          `Use 'formSubmitting', or apply this condition to a button or container instead.`,\n      );\n    }\n    applyLogicFn(config.type, path, createFormStateLogicFunction(config.condition));\n    return;\n  }\n\n  // Create appropriate logic function based on trigger\n  const logicFn =\n    trigger === 'debounced'\n      ? createDebouncedLogicFunction(config.condition as ConditionalExpression, debounceMs)\n      : createLogicFunction(config.condition as ConditionalExpression);\n\n  applyLogicFn(config.type, path, logicFn);\n}\n\nfunction applyLogicFn<TValue>(type: StateLogicType, path: SchemaPath<TValue>, logicFn: AnyLogicFn<TValue>): void {\n  switch (type) {\n    case 'hidden':\n      hidden(path, logicFn);\n      break;\n    case 'readonly':\n      readonly(path, logicFn);\n      break;\n    case 'disabled':\n      disabled(path, logicFn);\n      break;\n    case 'required':\n      required(path, { when: logicFn });\n      break;\n    default: {\n      const _exhaustive: never = type;\n      throw new DynamicFormError(`Unhandled state logic type: ${_exhaustive}`);\n    }\n  }\n}\n\nexport function applyMultipleLogic<TValue>(configs: LogicConfig[], fieldPath: SchemaPath<TValue> | SchemaPathTree<TValue>): void {\n  configs.forEach((config) => applyLogic(config, fieldPath));\n}\n","import type { Logger } from '@ng-forge/dynamic-forms/internal';\nimport { ExpressionParser } from '@ng-forge/dynamic-forms/internal';\n\n/**\n * Create a type predicate function from a predicate string.\n *\n * @param predicate - A JavaScript expression that evaluates to boolean. The value to check is available as `value`.\n * @param logger - Logger for error reporting\n * @returns A type predicate function\n */\nexport function createTypePredicateFunction<T = unknown>(predicate: string, logger: Logger): (value: unknown) => value is T {\n  return (value: unknown): value is T => {\n    try {\n      // Evaluate using secure AST-based parser with value in scope\n      const result = ExpressionParser.evaluate(predicate, { value });\n      return Boolean(result);\n    } catch (error) {\n      logger.error('Error evaluating type predicate:', predicate, error);\n      return false;\n    }\n  };\n}\n","import { inject } from '@angular/core';\nimport { apply, applyEach, applyWhen, applyWhenValue, SchemaOrSchemaFn } from '@angular/forms/signals';\nimport type { SchemaPath, SchemaPathTree } from '@angular/forms/signals';\nimport { SchemaApplicationConfig, SchemaDefinition } from '@ng-forge/dynamic-forms/internal';\nimport { SchemaRegistryService } from './registry/schema-registry.service';\nimport { createLogicFunction } from '@ng-forge/dynamic-forms/internal';\nimport { createTypePredicateFunction } from './values/type-predicate-factory';\nimport { applyValidator } from '@ng-forge/dynamic-forms/internal';\nimport { applyLogic } from './logic/logic-applicator';\nimport { DynamicFormLogger, type Logger } from '@ng-forge/dynamic-forms/internal';\n\n/**\n * Apply schema configuration.\n * Accepts both SchemaPath and SchemaPathTree for flexibility.\n */\nexport function applySchema(config: SchemaApplicationConfig, fieldPath: SchemaPath<unknown> | SchemaPathTree<unknown>): void {\n  const logger = inject(DynamicFormLogger);\n  const schemaRegistry = inject(SchemaRegistryService);\n  const schema = schemaRegistry.resolveSchema(config.schema);\n\n  if (!schema) {\n    const availableSchemas = Array.from(schemaRegistry.getAllSchemas().keys()).join(', ') || '<none>';\n    logger.error(\n      `Schema not found: '${config.schema}'. ` +\n        `Available schemas: ${availableSchemas}. ` +\n        `Ensure the schema is registered in your schema registry.`,\n    );\n    return;\n  }\n\n  const schemaFn = createSchemaFunction(schema, logger);\n\n  // Cast to suppress union type errors - safe because we only use signal forms (see function docs)\n  const path = fieldPath as SchemaPath<unknown>;\n\n  switch (config.type) {\n    case 'apply':\n      apply(path, schemaFn);\n      break;\n\n    case 'applyWhen':\n      if (config.condition) {\n        const conditionFn = createLogicFunction(config.condition);\n        applyWhen(path, conditionFn, schemaFn);\n      }\n      break;\n\n    case 'applyWhenValue':\n      if (config.typePredicate) {\n        const predicate = createTypePredicateFunction(config.typePredicate, logger);\n        applyWhenValue(path, predicate, schemaFn);\n      }\n      break;\n\n    case 'applyEach':\n      applyEach(path as SchemaPath<unknown[]>, schemaFn);\n      break;\n  }\n}\n\n/** Create a schema function from schema definition. */\nexport function createSchemaFunction(schema: SchemaDefinition, logger?: Logger): SchemaOrSchemaFn<unknown> {\n  return (path: SchemaPathTree<unknown>) => {\n    // Apply validators - path is SchemaPathTree which is accepted by applyValidator\n    schema.validators?.forEach((validatorConfig) => {\n      applyValidator(validatorConfig, path);\n    });\n\n    // Apply logic - path is SchemaPathTree which is accepted by applyLogic\n    schema.logic?.forEach((logicConfig) => {\n      applyLogic(logicConfig, path);\n    });\n\n    // Apply sub-schemas - path is SchemaPathTree which is accepted by applySchema\n    schema.subSchemas?.forEach((subSchemaConfig) => {\n      applySchema(subSchemaConfig, path);\n    });\n  };\n}\n","import { FieldContext, LogicFn } from '@angular/forms/signals';\nimport { FieldDef } from '@ng-forge/dynamic-forms/internal';\nimport { FieldWithValidation } from '@ng-forge/dynamic-forms/internal';\nimport { isStateLogicConfig } from '@ng-forge/dynamic-forms/internal';\nimport { createLogicFunction } from '@ng-forge/dynamic-forms/internal';\n\n/**\n * Cascading configuration that flows from parent to child during schema mapping.\n *\n * @internal\n */\nexport interface FieldTreeMappingContext {\n  /**\n   * Whether validators on this field run while the field (or any ancestor) is\n   * hidden. Defaults to `false` at the global level.\n   */\n  readonly validateWhenHidden: boolean;\n\n  /**\n   * `true` when an ancestor is unconditionally hidden (`hidden: true` or\n   * `logic: [{type: 'hidden', condition: true}]`). When set together with\n   * `validateWhenHidden=false`, the descendant skips validator application\n   * entirely — there's no reactive case to gate on.\n   */\n  readonly ancestorAlwaysHidden: boolean;\n\n  /**\n   * Reactive logic functions for ancestor-level dynamic hidden conditions\n   * (`logic: [{type: 'hidden', condition: ...}]`). Layout containers do not\n   * have a schema path, so Angular Signal Forms cannot propagate their hidden\n   * state to descendants — this list does it manually. Each function evaluates\n   * against the current form value through the field context.\n   */\n  readonly ancestorHiddenLogics: readonly LogicFn<unknown, boolean>[];\n\n  /**\n   * `required` inherited from the nearest ancestor container that declared it\n   * (see `ContainerValidation.required`). `undefined` when no ancestor did.\n   *\n   * A field's own `required` always wins — `fieldDef.required ?? ancestorRequired`\n   * — so an explicit `required: false` opts back out of an inherited `true`.\n   */\n  readonly ancestorRequired?: boolean;\n}\n\n/**\n * Combines the inherited \"is any ancestor hidden\" check into a single LogicFn.\n * Returns `undefined` when no ancestor has dynamic hidden logic.\n *\n * @internal\n */\nexport function combineAncestorHiddenLogics(logics: readonly LogicFn<unknown, boolean>[]): LogicFn<unknown, boolean> | undefined {\n  if (logics.length === 0) return undefined;\n  if (logics.length === 1) return logics[0];\n  return (ctx: FieldContext<unknown>) => logics.some((fn) => fn(ctx));\n}\n\n/**\n * Returns the `FieldTreeMappingContext` to use **for the field itself** — i.e.\n * for gating its own validators. Only applies overrides that affect the field\n * (currently `validateWhenHidden`). The field's own hidden state is NOT folded\n * into `ancestorAlwaysHidden`/`ancestorHiddenLogics` here — Angular Signal\n * Forms already exposes that through `ctx.state.hidden()`, which the gate\n * checks separately.\n *\n * @internal\n */\nexport function resolveFieldOwnContext(\n  fieldDef: Pick<FieldDef<unknown>, 'validateWhenHidden'>,\n  parentContext: FieldTreeMappingContext,\n): FieldTreeMappingContext {\n  if (fieldDef.validateWhenHidden === undefined) return parentContext;\n  if (fieldDef.validateWhenHidden === parentContext.validateWhenHidden) return parentContext;\n  return {\n    ...parentContext,\n    validateWhenHidden: fieldDef.validateWhenHidden,\n  };\n}\n\n/**\n * Returns the `FieldTreeMappingContext` to use **for the field's descendants**.\n * Builds on top of `ownContext` by folding in the field's own hidden state so\n * children can correctly skip validation when this field hides them. Used for\n * groups, arrays, and layout containers that recurse into children.\n *\n * @internal\n */\nexport function resolveDescendantContext(\n  fieldDef: FieldDef<unknown> & Partial<Pick<FieldWithValidation, 'logic' | 'required'>>,\n  ownContext: FieldTreeMappingContext,\n): FieldTreeMappingContext {\n  let ancestorAlwaysHidden = ownContext.ancestorAlwaysHidden;\n  let ancestorHiddenLogics = ownContext.ancestorHiddenLogics;\n  let mutated = false;\n\n  // A container that declares `required` becomes the new inherited default for\n  // its subtree. Only `group` / `array` can express this (see ContainerValidation);\n  // layout containers have no such property in their types.\n  let ancestorRequired = ownContext.ancestorRequired;\n  if (fieldDef.required !== undefined && fieldDef.required !== ancestorRequired) {\n    ancestorRequired = fieldDef.required;\n    mutated = true;\n  }\n\n  if (fieldDef.hidden === true && !ancestorAlwaysHidden) {\n    ancestorAlwaysHidden = true;\n    mutated = true;\n  }\n\n  if (fieldDef.logic) {\n    for (const logic of fieldDef.logic) {\n      if (!isStateLogicConfig(logic) || logic.type !== 'hidden') continue;\n\n      const condition = logic.condition;\n\n      if (condition === true) {\n        if (!ancestorAlwaysHidden) {\n          ancestorAlwaysHidden = true;\n          mutated = true;\n        }\n        continue;\n      }\n\n      if (condition === false) continue;\n\n      // FormStateCondition strings ('formInvalid', etc.) are intended for buttons —\n      // they don't make sense as a \"field hidden\" trigger, so we skip them here.\n      if (typeof condition === 'string') continue;\n\n      // Dynamic — we need a reactive logic function. createLogicFunction\n      // requires an injection context, which the schema build provides.\n      const fn = createLogicFunction(condition) as LogicFn<unknown, boolean>;\n      ancestorHiddenLogics = ancestorHiddenLogics.length === 0 ? [fn] : [...ancestorHiddenLogics, fn];\n      mutated = true;\n    }\n  }\n\n  if (!mutated) return ownContext;\n\n  return {\n    validateWhenHidden: ownContext.validateWhenHidden,\n    ancestorAlwaysHidden,\n    ancestorHiddenLogics,\n    ancestorRequired,\n  };\n}\n","import {\n  applyEach,\n  applyWhen,\n  disabled,\n  email,\n  hidden,\n  max,\n  maxLength,\n  min,\n  minLength,\n  pattern,\n  readonly,\n  required,\n  schema,\n} from '@angular/forms/signals';\nimport type { FieldContext, SchemaPath, SchemaPathTree } from '@angular/forms/signals';\nimport { FieldDef } from '@ng-forge/dynamic-forms/internal';\nimport { FieldWithValidation } from '@ng-forge/dynamic-forms/internal';\nimport { ContainerValidation } from '@ng-forge/dynamic-forms/internal';\nimport { applyValidator } from '@ng-forge/dynamic-forms/internal';\nimport { applyLogic } from './logic/logic-applicator';\nimport { applySchema } from './schema-application';\nimport { isGroupField } from '@ng-forge/dynamic-forms/internal';\nimport { isArrayField } from '@ng-forge/dynamic-forms/internal';\nimport { isPageField } from '@ng-forge/dynamic-forms/internal';\nimport { isRowField } from '@ng-forge/dynamic-forms/internal';\nimport { isGenericContainerField } from '@ng-forge/dynamic-forms/internal';\nimport { getNormalizedArrayMetadata } from '../utils/array-field/normalized-array-metadata';\nimport { DynamicFormError } from '@ng-forge/dynamic-forms/internal';\nimport { isStateLogicConfig, LogicConfig } from '@ng-forge/dynamic-forms/internal';\nimport {\n  combineAncestorHiddenLogics,\n  FieldTreeMappingContext,\n  resolveDescendantContext,\n  resolveFieldOwnContext,\n} from './field-tree-mapping-context';\n\n/**\n * Default {@link FieldTreeMappingContext} used when no inherited context is provided.\n * Mirrors the global token defaults so callers that bypass `createSchemaFromFields`\n * (e.g. nested group forms) still get sensible behavior.\n */\nconst DEFAULT_FIELD_TREE_MAPPING_CONTEXT: FieldTreeMappingContext = {\n  validateWhenHidden: false,\n  ancestorAlwaysHidden: false,\n  ancestorHiddenLogics: [],\n};\n\n// Type alias for schema path parameters\ntype AnySchemaPath = SchemaPath<unknown> | SchemaPathTree<unknown>;\n\n// ============================================================================\n// Type-safe validator application functions\n// ============================================================================\n\ninterface StringValidationConfig {\n  email?: boolean;\n  minLength?: number;\n  maxLength?: number;\n  pattern?: string | RegExp;\n}\n\ninterface NumberValidationConfig {\n  min?: number;\n  max?: number;\n}\n\n/**\n * Applies string-specific validators to a schema path.\n * This function is properly typed - no casts needed internally.\n */\nfunction applyStringValidators(path: SchemaPath<string>, config: StringValidationConfig): void {\n  if (config.email) {\n    email(path);\n  }\n  if (config.minLength !== undefined) {\n    minLength(path, config.minLength);\n  }\n  if (config.maxLength !== undefined) {\n    maxLength(path, config.maxLength);\n  }\n  if (config.pattern) {\n    let regex: RegExp;\n    if (typeof config.pattern === 'string') {\n      try {\n        regex = new RegExp(config.pattern);\n      } catch (e) {\n        throw new DynamicFormError(`Invalid regex pattern: '${config.pattern}' — ${e instanceof Error ? e.message : String(e)}`);\n      }\n    } else {\n      regex = config.pattern;\n    }\n    pattern(path, regex);\n  }\n}\n\n/**\n * Applies number-specific validators to a schema path.\n * This function is properly typed - no casts needed internally.\n */\nfunction applyNumberValidators(path: SchemaPath<number>, config: NumberValidationConfig): void {\n  if (config.min !== undefined) {\n    min(path, config.min);\n  }\n  if (config.max !== undefined) {\n    max(path, config.max);\n  }\n}\n\n/**\n * Extracts string validation config from a field definition.\n * Returns undefined if no string validators are configured.\n */\nfunction getStringValidationConfig(fieldDef: FieldWithValidation): StringValidationConfig | undefined {\n  if (!fieldDef.email && fieldDef.minLength === undefined && fieldDef.maxLength === undefined && !fieldDef.pattern) {\n    return undefined;\n  }\n  return {\n    email: fieldDef.email,\n    minLength: fieldDef.minLength,\n    maxLength: fieldDef.maxLength,\n    pattern: fieldDef.pattern,\n  };\n}\n\n/**\n * Extracts number validation config from a field definition.\n * Handles both 'min'/'max' (standard) and 'minValue'/'maxValue' (SliderField).\n * Returns undefined if no number validators are configured.\n */\nfunction getNumberValidationConfig(fieldDef: FieldWithValidation): NumberValidationConfig | undefined {\n  const minVal = fieldDef.min ?? (fieldDef as { minValue?: number }).minValue;\n  const maxVal = fieldDef.max ?? (fieldDef as { maxValue?: number }).maxValue;\n\n  if (minVal === undefined && maxVal === undefined) {\n    return undefined;\n  }\n  return { min: minVal, max: maxVal };\n}\n\n/** Returns whether mapping this leaf needs a validation schema branch. */\nexport function hasValidationRules(fieldDef: FieldDef<unknown> & FieldWithValidation, context: FieldTreeMappingContext): boolean {\n  const declaresRequiredLogic = fieldDef.logic?.some(isValidationStateLogic) ?? false;\n  const required = fieldDef.required ?? (declaresRequiredLogic ? false : context.ancestorRequired);\n\n  return (\n    required === true ||\n    declaresRequiredLogic ||\n    getStringValidationConfig(fieldDef) !== undefined ||\n    getNumberValidationConfig(fieldDef) !== undefined ||\n    (fieldDef.validators?.length ?? 0) > 0\n  );\n}\n\n/**\n * Maps a field definition to the Angular Signal Forms schema.\n *\n * @param fieldDef Field definition to map\n * @param fieldPath Schema path for this field\n * @param inheritedContext Cascading mapping context from the parent. Field-level\n *   overrides on `fieldDef` are merged on top and passed down to descendants. Defaults\n *   to {@link DEFAULT_FIELD_TREE_MAPPING_CONTEXT} when omitted.\n */\nexport function mapFieldToForm(\n  fieldDef: FieldDef<unknown>,\n  fieldPath: AnySchemaPath,\n  inheritedContext: FieldTreeMappingContext = DEFAULT_FIELD_TREE_MAPPING_CONTEXT,\n): void {\n  const ownContext = resolveFieldOwnContext(fieldDef, inheritedContext);\n\n  // Layout containers (page, row, container) - flatten children to current level.\n  // Layout containers have no schema path of their own, so any hidden state on them\n  // must be propagated to descendants through the cascade.\n  if (isPageField(fieldDef) || isRowField(fieldDef) || isGenericContainerField(fieldDef)) {\n    const descendantContext = resolveDescendantContext(fieldDef, ownContext);\n    mapContainerChildren(fieldDef.fields as FieldDef<unknown>[] | undefined, fieldPath, descendantContext);\n    return;\n  }\n\n  // Group fields - map children under the group's path. Groups have a schema path,\n  // so Angular Signal Forms can propagate `hidden(path, ...)` calls to descendants —\n  // but groups don't currently apply their own hidden state, so we still propagate\n  // through the cascade as a belt-and-suspenders fallback.\n  if (isGroupField(fieldDef)) {\n    const descendantContext = resolveDescendantContext(fieldDef, ownContext);\n    applyContainerValidators(fieldDef, fieldPath, descendantContext);\n    mapContainerChildren(fieldDef.fields, fieldPath, descendantContext);\n    return;\n  }\n\n  // Array fields - use applyEach for item schema.\n  if (isArrayField(fieldDef)) {\n    const descendantContext = resolveDescendantContext(fieldDef, ownContext);\n    mapArrayFieldToForm(fieldDef, fieldPath, descendantContext);\n    return;\n  }\n\n  // Leaf field - apply validation, logic, and configuration. Use the field's OWN\n  // context (no descendant propagation) because the leaf's own hidden state is\n  // already exposed via `ctx.state.hidden()`.\n  mapLeafField(fieldDef, fieldPath, ownContext);\n}\n\n/** Maps children of a container field (page, row, group) to the form schema. */\nfunction mapContainerChildren(\n  fields: readonly FieldDef<unknown>[] | undefined,\n  parentPath: AnySchemaPath,\n  inheritedContext: FieldTreeMappingContext,\n): void {\n  if (!fields) return;\n\n  const pathRecord = parentPath as Record<string, AnySchemaPath>;\n\n  for (const field of fields) {\n    if (isPageField(field) || isRowField(field) || isGenericContainerField(field)) {\n      // Layout containers can still carry their own cascading overrides that flow\n      // down to their flattened descendants.\n      const layoutOwn = resolveFieldOwnContext(field, inheritedContext);\n      const layoutDescendant = resolveDescendantContext(field, layoutOwn);\n      mapContainerChildren(field.fields as readonly FieldDef<unknown>[] | undefined, parentPath, layoutDescendant);\n      continue;\n    }\n\n    if (!field.key) continue;\n\n    const childPath = pathRecord[field.key];\n    if (childPath) {\n      mapFieldToForm(field, childPath, inheritedContext);\n    }\n  }\n}\n\n/**\n * Returns true for state logic that contributes validation (currently only `required`).\n * The other state logic types (`hidden`, `disabled`, `readonly`) must always apply,\n * even on hidden fields, so they're not gated by `validateWhenHidden`.\n */\nfunction isValidationStateLogic(config: LogicConfig): boolean {\n  return isStateLogicConfig(config) && config.type === 'required';\n}\n\n/**\n * Maps a leaf field (value-bearing field) to the form schema.\n *\n * @param context Resolved cascading context for this field. When\n *   `context.validateWhenHidden` is `false`, the field's validation block is wrapped\n *   in `applyWhen` keyed off `!ctx.state.hidden()`.\n */\nfunction mapLeafField(fieldDef: FieldDef<unknown>, fieldPath: AnySchemaPath, context: FieldTreeMappingContext): void {\n  const validationField = fieldDef as FieldDef<unknown> & FieldWithValidation;\n  const path = fieldPath as SchemaPath<unknown>;\n\n  // Always-applied: state logic (hidden/disabled/readonly), schemas, and value derivations.\n  // These must run regardless of hidden state — particularly the `hidden` logic itself,\n  // which establishes the very signal `applyWhen` reads below.\n  applyFieldState(fieldDef, path);\n\n  if (validationField.logic) {\n    for (const config of validationField.logic) {\n      if (!isValidationStateLogic(config)) {\n        applyLogic(config, fieldPath);\n      }\n    }\n  }\n\n  if (validationField.schemas) {\n    for (const config of validationField.schemas) {\n      applySchema(config, fieldPath);\n    }\n  }\n\n  if (!hasValidationRules(validationField, context)) {\n    return;\n  }\n\n  // Validation block — gated by `validateWhenHidden` when hidden.\n  const applyValidation = (validationPath: SchemaPath<unknown>): void => {\n    applySimpleValidationRules(validationField, validationPath, context);\n\n    if (validationField.validators) {\n      for (const config of validationField.validators) {\n        applyValidator(config, validationPath);\n      }\n    }\n\n    if (validationField.logic) {\n      for (const config of validationField.logic) {\n        if (isValidationStateLogic(config)) {\n          applyLogic(config, validationPath);\n        }\n      }\n    }\n  };\n\n  applyHiddenGatedValidation(path, context, applyValidation);\n}\n\n/** Applies a validation block through the `validateWhenHidden` gate. Shared by leaves and containers. */\nfunction applyHiddenGatedValidation(\n  path: SchemaPath<unknown>,\n  context: FieldTreeMappingContext,\n  apply: (validationPath: SchemaPath<unknown>) => void,\n): void {\n  if (context.validateWhenHidden) {\n    apply(path);\n    return;\n  }\n\n  // An ancestor is unconditionally hidden — there is no reactive case for the\n  // validators to ever fire, so we simply do not apply them.\n  if (context.ancestorAlwaysHidden) {\n    return;\n  }\n\n  // applyWhen conditionally applies a sub-schema. The gate combines:\n  // - the field's own `state.hidden()` (set by Angular Signal Forms whenever\n  //   `hidden(path, ...)` was called for this field or any ancestor with a\n  //   path); and\n  // - any ancestor dynamic hidden logic that does NOT live on a schema path\n  //   (layout containers — see field-tree-mapping-context for details).\n  const ancestorHiddenLogic = combineAncestorHiddenLogics(context.ancestorHiddenLogics);\n  applyWhen(\n    path,\n    (ctx: FieldContext<unknown>) => {\n      if (ctx.state.hidden()) return false;\n      if (ancestorHiddenLogic && ancestorHiddenLogic(ctx)) return false;\n      return true;\n    },\n    schema<unknown>((subPath) => apply(subPath as SchemaPath<unknown>)),\n  );\n}\n\n/**\n * Applies a container's own `validators` to its schema path (#568).\n * `context` must be the DESCENDANT context — a group never calls `hidden()` on its own path.\n */\nfunction applyContainerValidators(fieldDef: FieldDef<unknown>, fieldPath: AnySchemaPath, context: FieldTreeMappingContext): void {\n  const validators = (fieldDef as FieldDef<unknown> & ContainerValidation).validators;\n  if (!validators || validators.length === 0) return;\n\n  applyHiddenGatedValidation(fieldPath as SchemaPath<unknown>, context, (validationPath) => {\n    for (const config of validators) {\n      applyValidator(config, validationPath, 'tree');\n    }\n  });\n}\n\n/**\n * Applies simple validation rules from field properties.\n * Casts are isolated to the boundary between untyped field definitions and typed validator functions.\n */\nfunction applySimpleValidationRules(fieldDef: FieldWithValidation, path: SchemaPath<unknown>, context: FieldTreeMappingContext): void {\n  // Own `required` wins over an inherited one, so `required: false` opts out. A child\n  // whose requiredness is conditional (`logic: [{ type: 'required', when }]`) also opts\n  // out — an unconditional cascade on top would make that condition unreachable.\n  const declaresRequiredLogic = fieldDef.logic?.some(isValidationStateLogic) ?? false;\n  if (fieldDef.required ?? (declaresRequiredLogic ? false : context.ancestorRequired)) {\n    required(path);\n  }\n\n  // String validators - single cast at boundary\n  const stringConfig = getStringValidationConfig(fieldDef);\n  if (stringConfig) {\n    applyStringValidators(path as SchemaPath<string>, stringConfig);\n  }\n\n  // Number validators - single cast at boundary\n  const numberConfig = getNumberValidationConfig(fieldDef);\n  if (numberConfig) {\n    applyNumberValidators(path as SchemaPath<number>, numberConfig);\n  }\n}\n\n/** Applies field state configuration (disabled, readonly, hidden). */\nfunction applyFieldState(fieldDef: FieldDef<unknown>, path: SchemaPath<unknown>): void {\n  if (fieldDef.disabled) {\n    disabled(path);\n  }\n\n  if (fieldDef.readonly) {\n    readonly(path);\n  }\n\n  if (fieldDef.hidden) {\n    hidden(path, () => true);\n  }\n}\n\n/** Maps an array field to the form schema using applyEach. */\nfunction mapArrayFieldToForm(arrayField: FieldDef<unknown>, fieldPath: AnySchemaPath, context: FieldTreeMappingContext): void {\n  if (!isArrayField(arrayField)) {\n    return;\n  }\n\n  // Apply array-level length validation\n  if (arrayField.minLength !== undefined) {\n    minLength(fieldPath as SchemaPath<unknown[]>, arrayField.minLength);\n  }\n  if (arrayField.maxLength !== undefined) {\n    maxLength(fieldPath as SchemaPath<unknown[]>, arrayField.maxLength);\n  }\n\n  applyContainerValidators(arrayField, fieldPath, context);\n\n  // Fields can be either FieldDef (primitive) or FieldDef[] (object)\n  let itemDefinitions = arrayField.fields as readonly (FieldDef<unknown> | readonly FieldDef<unknown>[])[];\n\n  // Simplified arrays initialized without `value` have empty `fields`; their\n  // item shape only lives in Symbol metadata. Fall back to that template so\n  // validators and logic declared inside it still apply when items are\n  // materialized from a programmatically-set form value.\n  if (!itemDefinitions || itemDefinitions.length === 0) {\n    const metadataTemplate = getNormalizedArrayMetadata(arrayField)?.template;\n    if (metadataTemplate) {\n      itemDefinitions = [\n        Array.isArray(metadataTemplate) ? [...(metadataTemplate as readonly FieldDef<unknown>[])] : (metadataTemplate as FieldDef<unknown>),\n      ];\n    }\n  }\n\n  // Empty array with no template metadata - items will be added via buttons with\n  // their own templates. Create a minimal schema that just accepts any value.\n  if (!itemDefinitions || itemDefinitions.length === 0) {\n    const emptyItemSchema = schema<unknown>(() => {\n      // No fields to map - items will be added dynamically via buttons\n    });\n    applyEach(fieldPath as SchemaPath<unknown[]>, emptyItemSchema);\n    return;\n  }\n\n  // Analyze item definitions to determine schema type\n  let hasPrimitiveItems = false;\n  const allObjectFields: FieldDef<unknown>[] = [];\n\n  for (const itemDef of itemDefinitions) {\n    if (Array.isArray(itemDef)) {\n      // Object item: collect fields for superset schema\n      collectFieldsFromObjectItem(itemDef as readonly FieldDef<unknown>[], allObjectFields);\n    } else if (\n      isPageField(itemDef as FieldDef<unknown>) ||\n      isRowField(itemDef as FieldDef<unknown>) ||\n      isGenericContainerField(itemDef as FieldDef<unknown>)\n    ) {\n      // Layout container as a single-template item: its descendants describe\n      // the item's object shape. Hand it to the object-item collector wrapped\n      // as a 1-element array so the structured-item mapping path runs.\n      collectFieldsFromObjectItem([itemDef as FieldDef<unknown>], allObjectFields);\n    } else {\n      // Primitive item: single FieldDef\n      hasPrimitiveItems = true;\n    }\n  }\n\n  // For pure primitive arrays, use a simple schema\n  if (hasPrimitiveItems && allObjectFields.length === 0) {\n    const primitiveItemSchema = schema<unknown>(() => {\n      // Primitive items don't need field mapping - just accept any value\n    });\n    applyEach(fieldPath as SchemaPath<unknown[]>, primitiveItemSchema);\n    return;\n  }\n\n  // For object or mixed arrays, use object schema with optional fields\n  // Mixed arrays use the superset of all object fields (primitive items are just values)\n  const itemSchema = schema<Record<string, unknown>>((itemPath) => {\n    const pathRecord = itemPath as Record<string, AnySchemaPath>;\n\n    // Map ALL unique template fields from all object items\n    for (const templateField of allObjectFields) {\n      if (isRowField(templateField) || isPageField(templateField) || isGenericContainerField(templateField)) {\n        // Row/page/container templates flatten their children\n        const layoutOwn = resolveFieldOwnContext(templateField, context);\n        const layoutDescendant = resolveDescendantContext(templateField, layoutOwn);\n        mapContainerChildren(templateField.fields as FieldDef<unknown>[] | undefined, itemPath, layoutDescendant);\n      } else if (isGroupField(templateField)) {\n        const groupKey = templateField.key;\n        if (groupKey) {\n          // Via mapFieldToForm so the group's own validators apply, not just its children.\n          const groupPath = pathRecord[groupKey];\n          if (groupPath) {\n            mapFieldToForm(templateField, groupPath, context);\n          }\n        } else {\n          // No group key - apply children directly (edge case)\n          const groupOwn = resolveFieldOwnContext(templateField, context);\n          mapContainerChildren(templateField.fields, itemPath, resolveDescendantContext(templateField, groupOwn));\n        }\n      } else {\n        // Simple field template - get the specific field's path\n        const fieldKey = templateField.key;\n        if (fieldKey) {\n          const fieldPathForKey = pathRecord[fieldKey];\n          if (fieldPathForKey) {\n            mapFieldToForm(templateField, fieldPathForKey, context);\n          }\n        }\n      }\n    }\n  });\n\n  applyEach(fieldPath as SchemaPath<Record<string, unknown>[]>, itemSchema);\n}\n\n/**\n * Collects unique field definitions from an object item template.\n * Uses field key as the uniqueness identifier.\n * When the same key appears in multiple templates, uses the first occurrence.\n */\nfunction collectFieldsFromObjectItem(itemFields: readonly FieldDef<unknown>[], allFields: FieldDef<unknown>[]): void {\n  const seenKeys = new Set(allFields.map((f) => f.key).filter(Boolean));\n\n  for (const field of itemFields) {\n    // For row/page/container fields, we need to collect their children's keys\n    if (isRowField(field) || isPageField(field) || isGenericContainerField(field)) {\n      // Use a synthetic key for container fields to dedupe them\n      const containerKey = `__container_${field.type}_${JSON.stringify(field.fields?.map((f) => f.key))}`;\n      if (!seenKeys.has(containerKey)) {\n        seenKeys.add(containerKey);\n        allFields.push(field);\n      }\n    } else {\n      const key = field.key;\n      if (key && !seenKeys.has(key)) {\n        seenKeys.add(key);\n        allFields.push(field);\n      }\n    }\n  }\n}\n","import { inject } from '@angular/core';\nimport { Schema, schema } from '@angular/forms/signals';\nimport type { SchemaPath, SchemaPathTree } from '@angular/forms/signals';\nimport { FieldDef } from '@ng-forge/dynamic-forms/internal';\nimport { mapFieldToForm } from './form-mapping';\nimport { FieldTypeDefinition, getFieldValueHandling } from '@ng-forge/dynamic-forms/internal';\nimport { getFieldDefaultValue } from '../utils/default-value/default-value';\nimport { hasChildFields } from '@ng-forge/dynamic-forms/internal';\nimport { normalizeFieldsArray } from '@ng-forge/dynamic-forms/internal';\nimport { applyFormLevelSchema } from './form-schema-merger';\nimport type { FormSchema } from '@ng-forge/dynamic-forms/schema';\nimport { VALIDATION_EXECUTION_DEFAULTS } from '../providers/features/validation-execution/validation-execution.token';\nimport { FieldTreeMappingContext, resolveDescendantContext, resolveFieldOwnContext } from './field-tree-mapping-context';\n\n/** Options for creating a schema from field definitions. */\nexport interface CreateSchemaOptions<TModel = unknown> {\n  /** Optional form-level Standard Schema for additional validation. */\n  formLevelSchema?: FormSchema<TModel>;\n\n  /** Form-level `validateWhenHidden` setting (from `FormConfig.options.validateWhenHidden`). */\n  validateWhenHidden?: boolean;\n}\n\n/**\n * Creates an Angular signal forms schema from field definitions\n * This is the single entry point at dynamic form level that replaces createSchemaFromFields\n * Uses the new modular signal forms adapter structure\n *\n * @param fields Field definitions to create schema from\n * @param registry Field type registry\n * @param options Optional configuration object\n */\nexport function createSchemaFromFields<TModel = unknown>(\n  fields: FieldDef<unknown>[],\n  registry: Map<string, FieldTypeDefinition>,\n  options: CreateSchemaOptions<TModel> = {},\n): Schema<TModel> {\n  // Inject services for form-level schema construction\n  // These will be available because createSchemaFromFields is called within runInInjectionContext\n  const validationExecutionDefaults = inject(VALIDATION_EXECUTION_DEFAULTS);\n\n  const { formLevelSchema } = options;\n  const rootContext: FieldTreeMappingContext = {\n    validateWhenHidden: options.validateWhenHidden ?? validationExecutionDefaults.validateWhenHidden,\n    ancestorAlwaysHidden: false,\n    ancestorHiddenLogics: [],\n  };\n\n  return schema<TModel>((path) => {\n    for (const fieldDef of fields) {\n      const valueHandling = getFieldValueHandling(fieldDef.type, registry);\n\n      // Handle different value handling modes\n      if (valueHandling === 'exclude') {\n        // Skip fields that don't contribute to form values\n        continue;\n      }\n\n      if (valueHandling === 'flatten' && hasChildFields(fieldDef)) {\n        // A flatten container can still set its own cascading overrides that flow\n        // down to its children — including its own hidden state which has no\n        // schema path of its own.\n        const flattenedOwn = resolveFieldOwnContext(fieldDef, rootContext);\n        const flattenedContext = resolveDescendantContext(fieldDef, flattenedOwn);\n        for (const childField of normalizeFieldsArray(fieldDef.fields)) {\n          if (!childField.key) continue;\n\n          const childPath = (path as Record<string, SchemaPath<unknown>>)[childField.key];\n          if (childPath) {\n            mapFieldToForm(childField, childPath, flattenedContext);\n          }\n        }\n        continue;\n      }\n\n      // Regular field processing for 'include' fields\n      const fieldPath = (path as Record<string, SchemaPath<unknown>>)[fieldDef.key];\n\n      if (!fieldPath) {\n        continue;\n      }\n\n      // Use the new modular form mapping function\n      // This will progressively apply validators, logic, and schemas\n      // Cross-field logic is handled automatically via RootFormRegistryService\n      mapFieldToForm(fieldDef, fieldPath, rootContext);\n    }\n\n    // Apply form-level Standard Schema validation\n    if (formLevelSchema) {\n      applyFormLevelSchema(path as SchemaPathTree<TModel>, formLevelSchema);\n    }\n  });\n}\n\n/** Utility to convert field definitions to default values object */\nexport function fieldsToDefaultValues<TModel = unknown>(fields: FieldDef<unknown>[], registry: Map<string, FieldTypeDefinition>): TModel {\n  const defaultValues: Record<string, unknown> = {};\n\n  for (const field of fields) {\n    if (!field.key) continue;\n\n    // Skip flatten fields (row/page) at top level - they are presentational containers\n    const valueHandling = getFieldValueHandling(field.type, registry);\n    if (valueHandling === 'flatten') {\n      continue;\n    }\n\n    const value = getFieldDefaultValue(field, registry);\n    if (value !== undefined) {\n      defaultValues[field.key] = value;\n    }\n  }\n\n  return defaultValues as TModel;\n}\n"]}