@ngx-formly/core 6.3.12 → 7.0.0-alpha.1

package/esm2022/lib/extensions/field-form/field-form.mjs

@@ -0,0 +1,141 @@
+import { UntypedFormGroup, UntypedFormControl, Validators, FormControl, } from '@angular/forms';
+import { getFieldValue, defineHiddenProp, hasKey, getKeyPath } from '../../utils';
+import { registerControl, findControl, updateValidity } from './utils';
+import { of } from 'rxjs';
+export class FieldFormExtension {
+    prePopulate(field) {
+        if (!this.root) {
+            this.root = field;
+        }
+        if (field.parent) {
+            Object.defineProperty(field, 'form', {
+                get: () => field.parent.formControl,
+                configurable: true,
+            });
+        }
+    }
+    onPopulate(field) {
+        if (field.hasOwnProperty('fieldGroup') && !hasKey(field)) {
+            defineHiddenProp(field, 'formControl', field.form);
+        }
+        else {
+            this.addFormControl(field);
+        }
+    }
+    postPopulate(field) {
+        if (this.root !== field) {
+            return;
+        }
+        this.root = null;
+        const markForCheck = this.setValidators(field);
+        if (markForCheck && field.parent) {
+            let parent = field.parent;
+            while (parent) {
+                if (hasKey(parent) || !parent.parent) {
+                    updateValidity(parent.formControl, true);
+                }
+                parent = parent.parent;
+            }
+        }
+    }
+    addFormControl(field) {
+        let control = findControl(field);
+        if (field.fieldArray) {
+            return;
+        }
+        if (!control) {
+            const controlOptions = { updateOn: field.modelOptions.updateOn };
+            if (field.fieldGroup) {
+                control = new UntypedFormGroup({}, controlOptions);
+            }
+            else {
+                const value = hasKey(field) ? getFieldValue(field) : field.defaultValue;
+                control = new UntypedFormControl({ value, disabled: !!field.props.disabled }, { ...controlOptions, initialValueIsDefault: true });
+            }
+        }
+        else {
+            if (control instanceof FormControl) {
+                const value = hasKey(field) ? getFieldValue(field) : field.defaultValue;
+                control.defaultValue = value;
+            }
+        }
+        registerControl(field, control);
+    }
+    setValidators(field, disabled = false) {
+        if (disabled === false && hasKey(field) && field.props?.disabled) {
+            disabled = true;
+        }
+        let markForCheck = false;
+        field.fieldGroup?.forEach((f) => f && this.setValidators(f, disabled) && (markForCheck = true));
+        if (hasKey(field) || !field.parent || (!hasKey(field) && !field.fieldGroup)) {
+            const { formControl: c } = field;
+            if (c) {
+                if (hasKey(field) && c instanceof FormControl) {
+                    if (disabled && c.enabled) {
+                        c.disable({ emitEvent: false, onlySelf: true });
+                        markForCheck = true;
+                    }
+                    if (!disabled && c.disabled) {
+                        c.enable({ emitEvent: false, onlySelf: true });
+                        markForCheck = true;
+                    }
+                }
+                if (null === c.validator && this.hasValidators(field, '_validators')) {
+                    c.setValidators(() => {
+                        const v = Validators.compose(this.mergeValidators(field, '_validators'));
+                        return v ? v(c) : null;
+                    });
+                    markForCheck = true;
+                }
+                if (null === c.asyncValidator && this.hasValidators(field, '_asyncValidators')) {
+                    c.setAsyncValidators(() => {
+                        const v = Validators.composeAsync(this.mergeValidators(field, '_asyncValidators'));
+                        return v ? v(c) : of(null);
+                    });
+                    markForCheck = true;
+                }
+                if (markForCheck) {
+                    updateValidity(c, true);
+                    // update validity of `FormGroup` instance created by field with nested key.
+                    let parent = c.parent;
+                    for (let i = 1; i < getKeyPath(field).length; i++) {
+                        if (parent) {
+                            updateValidity(parent, true);
+                            parent = parent.parent;
+                        }
+                    }
+                }
+            }
+        }
+        return markForCheck;
+    }
+    hasValidators(field, type) {
+        const c = field.formControl;
+        if (c?._fields?.length > 1 && c._fields.some((f) => f[type].length > 0)) {
+            return true;
+        }
+        else if (field[type].length > 0) {
+            return true;
+        }
+        return field.fieldGroup?.some((f) => f?.fieldGroup && !hasKey(f) && this.hasValidators(f, type));
+    }
+    mergeValidators(field, type) {
+        const validators = [];
+        const c = field.formControl;
+        if (c?._fields?.length > 1) {
+            c._fields
+                .filter((f) => !f._hide)
+                .forEach((f) => validators.push(...f[type]));
+        }
+        else if (field[type]) {
+            validators.push(...field[type]);
+        }
+        if (field.fieldGroup) {
+            field.fieldGroup
+                .filter((f) => f?.fieldGroup && !hasKey(f))
+                .forEach((f) => validators.push(...this.mergeValidators(f, type)));
+        }
+        return validators;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-form.js","sourceRoot":"","sources":["../../../../../../../src/core/src/lib/extensions/field-form/field-form.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormlyExtension, FormlyFieldConfigCache } from '../../models';\nimport {\n  UntypedFormGroup,\n  UntypedFormControl,\n  AbstractControlOptions,\n  Validators,\n  ValidatorFn,\n  AsyncValidatorFn,\n  FormControl,\n} from '@angular/forms';\nimport { getFieldValue, defineHiddenProp, hasKey, getKeyPath } from '../../utils';\nimport { registerControl, findControl, updateValidity } from './utils';\nimport { of } from 'rxjs';\n\nexport class FieldFormExtension implements FormlyExtension {\n  private root: FormlyFieldConfigCache;\n  prePopulate(field: FormlyFieldConfigCache) {\n    if (!this.root) {\n      this.root = field;\n    }\n\n    if (field.parent) {\n      Object.defineProperty(field, 'form', {\n        get: () => field.parent!.formControl,\n        configurable: true,\n      });\n    }\n  }\n\n  onPopulate(field: FormlyFieldConfigCache) {\n    if (field.hasOwnProperty('fieldGroup') && !hasKey(field)) {\n      defineHiddenProp(field, 'formControl', field.form);\n    } else {\n      this.addFormControl(field);\n    }\n  }\n\n  postPopulate(field: FormlyFieldConfigCache) {\n    if (this.root !== field) {\n      return;\n    }\n\n    this.root = null;\n    const markForCheck = this.setValidators(field);\n    if (markForCheck && field.parent) {\n      let parent = field.parent;\n      while (parent) {\n        if (hasKey(parent) || !parent.parent) {\n          updateValidity(parent.formControl, true);\n        }\n        parent = parent.parent;\n      }\n    }\n  }\n\n  private addFormControl(field: FormlyFieldConfigCache) {\n    let control = findControl(field);\n    if (field.fieldArray) {\n      return;\n    }\n\n    if (!control) {\n      const controlOptions: AbstractControlOptions = { updateOn: field.modelOptions.updateOn };\n\n      if (field.fieldGroup) {\n        control = new UntypedFormGroup({}, controlOptions);\n      } else {\n        const value = hasKey(field) ? getFieldValue(field) : field.defaultValue;\n        control = new UntypedFormControl(\n          { value, disabled: !!field.props.disabled },\n          { ...controlOptions, initialValueIsDefault: true },\n        );\n      }\n    } else {\n      if (control instanceof FormControl) {\n        const value = hasKey(field) ? getFieldValue(field) : field.defaultValue;\n        (control as any).defaultValue = value;\n      }\n    }\n\n    registerControl(field, control);\n  }\n\n  private setValidators(field: FormlyFieldConfigCache, disabled = false) {\n    if (disabled === false && hasKey(field) && field.props?.disabled) {\n      disabled = true;\n    }\n\n    let markForCheck = false;\n    field.fieldGroup?.forEach((f) => f && this.setValidators(f, disabled) && (markForCheck = true));\n    if (hasKey(field) || !field.parent || (!hasKey(field) && !field.fieldGroup)) {\n      const { formControl: c } = field;\n      if (c) {\n        if (hasKey(field) && c instanceof FormControl) {\n          if (disabled && c.enabled) {\n            c.disable({ emitEvent: false, onlySelf: true });\n            markForCheck = true;\n          }\n\n          if (!disabled && c.disabled) {\n            c.enable({ emitEvent: false, onlySelf: true });\n            markForCheck = true;\n          }\n        }\n\n        if (null === c.validator && this.hasValidators(field, '_validators')) {\n          c.setValidators(() => {\n            const v = Validators.compose(this.mergeValidators<ValidatorFn>(field, '_validators'));\n\n            return v ? v(c) : null;\n          });\n          markForCheck = true;\n        }\n\n        if (null === c.asyncValidator && this.hasValidators(field, '_asyncValidators')) {\n          c.setAsyncValidators(() => {\n            const v = Validators.composeAsync(this.mergeValidators<AsyncValidatorFn>(field, '_asyncValidators'));\n            return v ? v(c) : of(null);\n          });\n          markForCheck = true;\n        }\n\n        if (markForCheck) {\n          updateValidity(c, true);\n\n          // update validity of `FormGroup` instance created by field with nested key.\n          let parent = c.parent;\n          for (let i = 1; i < getKeyPath(field).length; i++) {\n            if (parent) {\n              updateValidity(parent, true);\n              parent = parent.parent;\n            }\n          }\n        }\n      }\n    }\n\n    return markForCheck;\n  }\n\n  private hasValidators(field: FormlyFieldConfigCache, type: '_validators' | '_asyncValidators'): boolean {\n    const c = field.formControl;\n    if (c?._fields?.length > 1 && c._fields.some((f) => f[type].length > 0)) {\n      return true;\n    } else if (field[type].length > 0) {\n      return true;\n    }\n\n    return field.fieldGroup?.some((f) => f?.fieldGroup && !hasKey(f) && this.hasValidators(f, type));\n  }\n\n  private mergeValidators<T>(field: FormlyFieldConfigCache, type: '_validators' | '_asyncValidators'): T[] {\n    const validators: any = [];\n    const c = field.formControl;\n    if (c?._fields?.length > 1) {\n      c._fields\n        .filter((f: FormlyFieldConfigCache) => !f._hide)\n        .forEach((f: FormlyFieldConfigCache) => validators.push(...f[type]));\n    } else if (field[type]) {\n      validators.push(...field[type]);\n    }\n\n    if (field.fieldGroup) {\n      field.fieldGroup\n        .filter((f) => f?.fieldGroup && !hasKey(f))\n        .forEach((f) => validators.push(...this.mergeValidators(f, type)));\n    }\n\n    return validators;\n  }\n}\n"]}

package/esm2022/lib/extensions/field-form/utils.mjs

@@ -0,0 +1,100 @@
+import { UntypedFormArray, UntypedFormGroup, FormControl } from '@angular/forms';
+import { getKeyPath, getFieldValue, isNil, defineHiddenProp, observe, hasKey } from '../../utils';
+export function unregisterControl(field, emitEvent = false) {
+    const control = field.formControl;
+    const fieldIndex = control._fields ? control._fields.indexOf(field) : -1;
+    if (fieldIndex !== -1) {
+        control._fields.splice(fieldIndex, 1);
+    }
+    const form = control.parent;
+    if (!form) {
+        return;
+    }
+    const opts = { emitEvent };
+    if (form instanceof UntypedFormArray) {
+        const key = form.controls.findIndex((c) => c === control);
+        if (key !== -1) {
+            form.removeAt(key, opts);
+        }
+    }
+    else if (form instanceof UntypedFormGroup) {
+        const paths = getKeyPath(field);
+        const key = paths[paths.length - 1];
+        if (form.get([key]) === control) {
+            form.removeControl(key, opts);
+        }
+    }
+    control.setParent(null);
+}
+export function findControl(field) {
+    if (field.formControl) {
+        return field.formControl;
+    }
+    if (field.shareFormControl === false) {
+        return null;
+    }
+    return field.form?.get(getKeyPath(field));
+}
+export function registerControl(field, control, emitEvent = false) {
+    control = control || field.formControl;
+    if (!control._fields) {
+        defineHiddenProp(control, '_fields', []);
+    }
+    if (control._fields.indexOf(field) === -1) {
+        control._fields.push(field);
+    }
+    if (!field.formControl && control) {
+        defineHiddenProp(field, 'formControl', control);
+        control.setValidators(null);
+        control.setAsyncValidators(null);
+        field.props.disabled = !!field.props.disabled;
+        const disabledObserver = observe(field, ['props', 'disabled'], ({ firstChange, currentValue }) => {
+            if (!firstChange) {
+                currentValue ? field.formControl.disable() : field.formControl.enable();
+            }
+        });
+        if (control instanceof FormControl) {
+            control.registerOnDisabledChange(disabledObserver.setValue);
+        }
+    }
+    if (!field.form || !hasKey(field)) {
+        return;
+    }
+    let form = field.form;
+    const paths = getKeyPath(field);
+    const value = getFieldValue(field);
+    if (!(isNil(control.value) && isNil(value)) && control.value !== value && control instanceof FormControl) {
+        control.patchValue(value);
+    }
+    for (let i = 0; i < paths.length - 1; i++) {
+        const path = paths[i];
+        if (!form.get([path])) {
+            form.setControl(path, new UntypedFormGroup({}), { emitEvent });
+        }
+        form = form.get([path]);
+    }
+    const key = paths[paths.length - 1];
+    if (!field._hide && form.get([key]) !== control) {
+        form.setControl(key, control, { emitEvent });
+    }
+}
+export function updateValidity(c, onlySelf = false) {
+    const status = c.status;
+    const value = c.value;
+    c.updateValueAndValidity({ emitEvent: false, onlySelf });
+    if (status !== c.status) {
+        c.statusChanges.emit(c.status);
+    }
+    if (value !== c.value) {
+        c.valueChanges.emit(c.value);
+    }
+}
+export function clearControl(form) {
+    delete form?._fields;
+    form.setValidators(null);
+    form.setAsyncValidators(null);
+    if (form instanceof UntypedFormGroup || form instanceof UntypedFormArray) {
+        Object.values(form.controls).forEach((c) => clearControl(c));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../src/core/src/lib/extensions/field-form/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { UntypedFormArray, UntypedFormGroup, AbstractControl, FormControl } from '@angular/forms';\nimport { getKeyPath, getFieldValue, isNil, defineHiddenProp, observe, hasKey } from '../../utils';\nimport { FormlyFieldConfigCache } from '../../models';\n\nexport function unregisterControl(field: FormlyFieldConfigCache, emitEvent = false) {\n  const control = field.formControl;\n  const fieldIndex = control._fields ? control._fields.indexOf(field) : -1;\n  if (fieldIndex !== -1) {\n    control._fields.splice(fieldIndex, 1);\n  }\n\n  const form = control.parent as UntypedFormArray | UntypedFormGroup;\n  if (!form) {\n    return;\n  }\n\n  const opts = { emitEvent };\n  if (form instanceof UntypedFormArray) {\n    const key = form.controls.findIndex((c) => c === control);\n    if (key !== -1) {\n      form.removeAt(key, opts);\n    }\n  } else if (form instanceof UntypedFormGroup) {\n    const paths = getKeyPath(field);\n    const key = paths[paths.length - 1];\n    if (form.get([key]) === control) {\n      form.removeControl(key, opts);\n    }\n  }\n\n  control.setParent(null);\n}\n\nexport function findControl(field: FormlyFieldConfigCache): AbstractControl {\n  if (field.formControl) {\n    return field.formControl;\n  }\n\n  if (field.shareFormControl === false) {\n    return null;\n  }\n\n  return field.form?.get(getKeyPath(field));\n}\n\nexport function registerControl(\n  field: FormlyFieldConfigCache,\n  control?: FormlyFieldConfigCache['formControl'],\n  emitEvent = false,\n) {\n  control = control || field.formControl;\n\n  if (!control._fields) {\n    defineHiddenProp(control, '_fields', []);\n  }\n  if (control._fields.indexOf(field) === -1) {\n    control._fields.push(field);\n  }\n\n  if (!field.formControl && control) {\n    defineHiddenProp(field, 'formControl', control);\n    control.setValidators(null);\n    control.setAsyncValidators(null);\n\n    field.props.disabled = !!field.props.disabled;\n    const disabledObserver = observe(field, ['props', 'disabled'], ({ firstChange, currentValue }) => {\n      if (!firstChange) {\n        currentValue ? field.formControl.disable() : field.formControl.enable();\n      }\n    });\n    if (control instanceof FormControl) {\n      control.registerOnDisabledChange(disabledObserver.setValue);\n    }\n  }\n\n  if (!field.form || !hasKey(field)) {\n    return;\n  }\n\n  let form = field.form;\n  const paths = getKeyPath(field);\n  const value = getFieldValue(field);\n  if (!(isNil(control.value) && isNil(value)) && control.value !== value && control instanceof FormControl) {\n    control.patchValue(value);\n  }\n\n  for (let i = 0; i < paths.length - 1; i++) {\n    const path = paths[i];\n    if (!form.get([path])) {\n      (form as UntypedFormGroup).setControl(path, new UntypedFormGroup({}), { emitEvent });\n    }\n\n    form = <UntypedFormGroup>form.get([path]);\n  }\n\n  const key = paths[paths.length - 1];\n  if (!field._hide && form.get([key]) !== control) {\n    (form as UntypedFormGroup).setControl(key, control, { emitEvent });\n  }\n}\n\nexport function updateValidity(c: AbstractControl, onlySelf = false) {\n  const status = c.status;\n  const value = c.value;\n  c.updateValueAndValidity({ emitEvent: false, onlySelf });\n  if (status !== c.status) {\n    (c.statusChanges as EventEmitter<string>).emit(c.status);\n  }\n\n  if (value !== c.value) {\n    (c.valueChanges as EventEmitter<any>).emit(c.value);\n  }\n}\n\nexport function clearControl(form: FormlyFieldConfigCache['formControl']) {\n  delete form?._fields;\n  form.setValidators(null);\n  form.setAsyncValidators(null);\n  if (form instanceof UntypedFormGroup || form instanceof UntypedFormArray) {\n    Object.values(form.controls).forEach((c) => clearControl(c));\n  }\n}\n"]}

package/esm2022/lib/extensions/field-validation/field-validation.mjs

@@ -0,0 +1,135 @@
+import { Validators } from '@angular/forms';
+import { FORMLY_VALIDATORS, defineHiddenProp, isPromise, observe, clone, isObject, hasKey } from '../../utils';
+import { updateValidity } from '../field-form/utils';
+import { isObservable } from 'rxjs';
+import { map } from 'rxjs/operators';
+export class FieldValidationExtension {
+    constructor(config) {
+        this.config = config;
+    }
+    onPopulate(field) {
+        this.initFieldValidation(field, 'validators');
+        this.initFieldValidation(field, 'asyncValidators');
+    }
+    initFieldValidation(field, type) {
+        const validators = [];
+        if (type === 'validators' && !(field.hasOwnProperty('fieldGroup') && !hasKey(field))) {
+            validators.push(this.getPredefinedFieldValidation(field));
+        }
+        if (field[type]) {
+            for (const validatorName of Object.keys(field[type])) {
+                validatorName === 'validation'
+                    ? validators.push(...field[type].validation.map((v) => this.wrapNgValidatorFn(field, v)))
+                    : validators.push(this.wrapNgValidatorFn(field, field[type][validatorName], validatorName));
+            }
+        }
+        defineHiddenProp(field, '_' + type, validators);
+    }
+    getPredefinedFieldValidation(field) {
+        let VALIDATORS = [];
+        FORMLY_VALIDATORS.forEach((opt) => observe(field, ['props', opt], ({ currentValue, firstChange }) => {
+            VALIDATORS = VALIDATORS.filter((o) => o !== opt);
+            if (opt === 'required' && currentValue != null && typeof currentValue !== 'boolean') {
+                console.warn(`Formly: Invalid prop 'required' of type '${typeof currentValue}', expected 'boolean' (Field:${field.key}).`);
+            }
+            if (currentValue != null && currentValue !== false) {
+                VALIDATORS.push(opt);
+            }
+            if (!firstChange && field.formControl) {
+                updateValidity(field.formControl);
+            }
+        }));
+        return (control) => {
+            if (VALIDATORS.length === 0) {
+                return null;
+            }
+            return Validators.compose(VALIDATORS.map((opt) => () => {
+                const value = field.props[opt];
+                switch (opt) {
+                    case 'required':
+                        return Validators.required(control);
+                    case 'pattern':
+                        return Validators.pattern(value)(control);
+                    case 'minLength':
+                        const minLengthResult = Validators.minLength(value)(control);
+                        const minLengthKey = this.config.getValidatorMessage('minlength') || field.validation?.messages?.minlength
+                            ? 'minlength'
+                            : 'minLength';
+                        return minLengthResult ? { [minLengthKey]: minLengthResult.minlength } : null;
+                    case 'maxLength':
+                        const maxLengthResult = Validators.maxLength(value)(control);
+                        const maxLengthKey = this.config.getValidatorMessage('maxlength') || field.validation?.messages?.maxlength
+                            ? 'maxlength'
+                            : 'maxLength';
+                        return maxLengthResult ? { [maxLengthKey]: maxLengthResult.maxlength } : null;
+                    case 'min':
+                        return Validators.min(value)(control);
+                    case 'max':
+                        return Validators.max(value)(control);
+                    default:
+                        return null;
+                }
+            }))(control);
+        };
+    }
+    wrapNgValidatorFn(field, validator, validatorName) {
+        let validatorOption;
+        if (typeof validator === 'string') {
+            validatorOption = clone(this.config.getValidator(validator));
+        }
+        if (typeof validator === 'object' && validator.name) {
+            validatorOption = clone(this.config.getValidator(validator.name));
+            if (validator.options) {
+                validatorOption.options = validator.options;
+            }
+        }
+        if (typeof validator === 'object' && validator.expression) {
+            const { expression, ...options } = validator;
+            validatorOption = {
+                name: validatorName,
+                validation: expression,
+                options: Object.keys(options).length > 0 ? options : null,
+            };
+        }
+        if (typeof validator === 'function') {
+            validatorOption = {
+                name: validatorName,
+                validation: validator,
+            };
+        }
+        return (control) => {
+            const errors = validatorOption.validation(control, field, validatorOption.options);
+            if (isPromise(errors)) {
+                return errors.then((v) => this.handleResult(field, validatorName ? !!v : v, validatorOption));
+            }
+            if (isObservable(errors)) {
+                return errors.pipe(map((v) => this.handleResult(field, validatorName ? !!v : v, validatorOption)));
+            }
+            return this.handleResult(field, validatorName ? !!errors : errors, validatorOption);
+        };
+    }
+    handleResult(field, errors, { name, options }) {
+        if (typeof errors === 'boolean') {
+            errors = errors ? null : { [name]: options ? options : true };
+        }
+        const ctrl = field.formControl;
+        ctrl?._childrenErrors?.[name]?.();
+        if (isObject(errors)) {
+            Object.keys(errors).forEach((name) => {
+                const errorPath = errors[name].errorPath ? errors[name].errorPath : options?.errorPath;
+                const childCtrl = errorPath ? field.formControl.get(errorPath) : null;
+                if (childCtrl) {
+                    const { errorPath: _errorPath, ...opts } = errors[name];
+                    childCtrl.setErrors({ ...(childCtrl.errors || {}), [name]: opts });
+                    !ctrl._childrenErrors && defineHiddenProp(ctrl, '_childrenErrors', {});
+                    ctrl._childrenErrors[name] = () => {
+                        const { [name]: _toDelete, ...childErrors } = childCtrl.errors || {};
+                        childCtrl.setErrors(Object.keys(childErrors).length === 0 ? null : childErrors);
+                    };
+                }
+            });
+        }
+        return errors;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-validation.js","sourceRoot":"","sources":["../../../../../../../src/core/src/lib/extensions/field-validation/field-validation.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormlyConfig } from '../../services/formly.config';\nimport { FormlyExtension, ValidatorOption, FormlyFieldConfigCache } from '../../models';\nimport { AbstractControl, Validators, ValidatorFn } from '@angular/forms';\nimport { FORMLY_VALIDATORS, defineHiddenProp, isPromise, observe, clone, isObject, hasKey } from '../../utils';\nimport { updateValidity } from '../field-form/utils';\nimport { isObservable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nexport class FieldValidationExtension implements FormlyExtension {\n  constructor(private config: FormlyConfig) {}\n\n  onPopulate(field: FormlyFieldConfigCache) {\n    this.initFieldValidation(field, 'validators');\n    this.initFieldValidation(field, 'asyncValidators');\n  }\n\n  private initFieldValidation(field: FormlyFieldConfigCache, type: 'validators' | 'asyncValidators') {\n    const validators: ValidatorFn[] = [];\n    if (type === 'validators' && !(field.hasOwnProperty('fieldGroup') && !hasKey(field))) {\n      validators.push(this.getPredefinedFieldValidation(field));\n    }\n\n    if (field[type]) {\n      for (const validatorName of Object.keys(field[type])) {\n        validatorName === 'validation'\n          ? validators.push(...field[type].validation.map((v: any) => this.wrapNgValidatorFn(field, v)))\n          : validators.push(this.wrapNgValidatorFn(field, field[type][validatorName], validatorName));\n      }\n    }\n\n    defineHiddenProp(field, '_' + type, validators);\n  }\n\n  private getPredefinedFieldValidation(field: FormlyFieldConfigCache): ValidatorFn {\n    let VALIDATORS: string[] = [];\n    FORMLY_VALIDATORS.forEach((opt) =>\n      observe(field, ['props', opt], ({ currentValue, firstChange }) => {\n        VALIDATORS = VALIDATORS.filter((o) => o !== opt);\n        if (opt === 'required' && currentValue != null && typeof currentValue !== 'boolean') {\n          console.warn(\n            `Formly: Invalid prop 'required' of type '${typeof currentValue}', expected 'boolean' (Field:${\n              field.key\n            }).`,\n          );\n        }\n\n        if (currentValue != null && currentValue !== false) {\n          VALIDATORS.push(opt);\n        }\n        if (!firstChange && field.formControl) {\n          updateValidity(field.formControl);\n        }\n      }),\n    );\n\n    return (control: AbstractControl) => {\n      if (VALIDATORS.length === 0) {\n        return null;\n      }\n\n      return Validators.compose(\n        VALIDATORS.map((opt) => () => {\n          const value = field.props[opt];\n          switch (opt) {\n            case 'required':\n              return Validators.required(control);\n            case 'pattern':\n              return Validators.pattern(value)(control);\n            case 'minLength':\n              const minLengthResult = Validators.minLength(value)(control);\n              const minLengthKey =\n                this.config.getValidatorMessage('minlength') || field.validation?.messages?.minlength\n                  ? 'minlength'\n                  : 'minLength';\n\n              return minLengthResult ? { [minLengthKey]: minLengthResult.minlength } : null;\n            case 'maxLength':\n              const maxLengthResult = Validators.maxLength(value)(control);\n              const maxLengthKey =\n                this.config.getValidatorMessage('maxlength') || field.validation?.messages?.maxlength\n                  ? 'maxlength'\n                  : 'maxLength';\n\n              return maxLengthResult ? { [maxLengthKey]: maxLengthResult.maxlength } : null;\n            case 'min':\n              return Validators.min(value)(control);\n            case 'max':\n              return Validators.max(value)(control);\n            default:\n              return null;\n          }\n        }),\n      )!(control);\n    };\n  }\n\n  private wrapNgValidatorFn(field: FormlyFieldConfigCache, validator: any, validatorName?: string) {\n    let validatorOption: ValidatorOption;\n    if (typeof validator === 'string') {\n      validatorOption = clone(this.config.getValidator(validator));\n    }\n\n    if (typeof validator === 'object' && validator.name) {\n      validatorOption = clone(this.config.getValidator(validator.name));\n      if (validator.options) {\n        validatorOption.options = validator.options;\n      }\n    }\n\n    if (typeof validator === 'object' && validator.expression) {\n      const { expression, ...options } = validator;\n      validatorOption = {\n        name: validatorName,\n        validation: expression,\n        options: Object.keys(options).length > 0 ? options : null,\n      };\n    }\n\n    if (typeof validator === 'function') {\n      validatorOption = {\n        name: validatorName,\n        validation: validator,\n      };\n    }\n\n    return (control: AbstractControl) => {\n      const errors: any = validatorOption.validation(control, field, validatorOption.options);\n      if (isPromise(errors)) {\n        return errors.then((v) => this.handleResult(field, validatorName ? !!v : v, validatorOption));\n      }\n\n      if (isObservable(errors)) {\n        return errors.pipe(map((v) => this.handleResult(field, validatorName ? !!v : v, validatorOption)));\n      }\n\n      return this.handleResult(field, validatorName ? !!errors : errors, validatorOption);\n    };\n  }\n\n  private handleResult(field: FormlyFieldConfigCache, errors: any, { name, options }: ValidatorOption) {\n    if (typeof errors === 'boolean') {\n      errors = errors ? null : { [name]: options ? options : true };\n    }\n\n    const ctrl = field.formControl;\n    ctrl?._childrenErrors?.[name]?.();\n\n    if (isObject(errors)) {\n      Object.keys(errors).forEach((name) => {\n        const errorPath = errors[name].errorPath ? errors[name].errorPath : options?.errorPath;\n\n        const childCtrl = errorPath ? field.formControl.get(errorPath) : null;\n        if (childCtrl) {\n          const { errorPath: _errorPath, ...opts } = errors[name];\n          childCtrl.setErrors({ ...(childCtrl.errors || {}), [name]: opts });\n\n          !ctrl._childrenErrors && defineHiddenProp(ctrl, '_childrenErrors', {});\n          ctrl._childrenErrors[name] = () => {\n            const { [name]: _toDelete, ...childErrors } = childCtrl.errors || {};\n            childCtrl.setErrors(Object.keys(childErrors).length === 0 ? null : childErrors);\n          };\n        }\n      });\n    }\n\n    return errors;\n  }\n}\n"]}

package/esm2022/lib/extensions/index.mjs

@@ -0,0 +1,2 @@
+export { FieldExpressionExtension } from './field-expression/field-expression';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29yZS9zcmMvbGliL2V4dGVuc2lvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0scUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBGaWVsZEV4cHJlc3Npb25FeHRlbnNpb24gfSBmcm9tICcuL2ZpZWxkLWV4cHJlc3Npb24vZmllbGQtZXhwcmVzc2lvbic7XG4iXX0=

package/esm2022/lib/models/fieldconfig.cache.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/fieldconfig.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fieldconfig.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/models/fieldconfig.ts"],"names":[],"mappings":"","sourcesContent":["import {\n  UntypedFormGroup,\n  UntypedFormArray,\n  AbstractControl,\n  FormGroupDirective,\n  ValidatorFn,\n  AsyncValidatorFn,\n} from '@angular/forms';\nimport { Subject, Observable } from 'rxjs';\nimport { FieldType } from '../templates/field.type';\nimport { FieldWrapper } from '../templates/field.wrapper';\nimport { ValidationMessageOption } from '../models';\nimport { Type } from '@angular/core';\n\ntype FieldExpression<T = any> = string | ((field: FormlyFieldConfig) => T) | Observable<T>;\ntype FieldExpressions = { [property: string]: FieldExpression } & {\n  className?: FieldExpression<string>;\n  hide?: FieldExpression<boolean>;\n  'props.disabled'?: FieldExpression<boolean>;\n  'props.required'?: FieldExpression<boolean>;\n};\n\nexport interface FormlyFieldConfig<Props = FormlyFieldProps & { [additionalProperties: string]: any }> {\n  /**\n   * The key that relates to the model. This will link the field value to the model\n   */\n  key?: string | number | (string | number)[];\n\n  /**\n   * This should be a formly-field type added either by you or a plugin. More information over at Creating Formly Fields.\n   */\n  type?: string | Type<FieldType>;\n\n  /**\n   * Use `defaultValue` to initialize it the model. If this is provided and the value of the model at compile-time is undefined, then the value of the model will be assigned to `defaultValue`.\n   */\n  defaultValue?: any;\n\n  /**\n   * This allows you to specify the `id` of your field. Note, the `id` is generated if not set.\n   */\n  id?: string;\n\n  /**\n   * If you wish, you can specify a specific `name` for your field. This is useful if you're posting the form to a server using techniques of yester-year.\n   */\n  name?: string;\n\n  /**\n   * This is reserved for the templates. Any template-specific options go in here. Look at your specific template implementation to know the options required for this.\n   */\n  props?: Props;\n\n  /** @deprecated Use `props` instead. */\n  templateOptions?: FormlyTemplateOptions;\n\n  /**\n   * An object with a few useful properties\n   * - `validation.messages`: A map of message names that will be displayed when the field has errors.\n   * - `validation.show`: A boolean you as the developer can set to force displaying errors whatever the state of field. This is useful when you're trying to call the user's attention to some fields for some reason.\n   */\n  validation?: {\n    messages?: { [messageProperties: string]: ValidationMessageOption['message'] } & {\n      /** @deprecated use `minLength` */\n      minlength?: ValidationMessageOption['message'];\n\n      /** @deprecated use `maxLength` */\n      maxlength?: ValidationMessageOption['message'];\n    };\n    show?: boolean;\n    [additionalProperties: string]: any;\n  };\n\n  /**\n   * Used to set validation rules for a particular field.\n   * Should be an object of key - value pairs. The value can either be an expression to evaluate or a function to run.\n   * Each should return a boolean value, returning true when the field is valid. See Validation for more information.\n   */\n  validators?: FormlyValidation<ValidatorFn, boolean>;\n\n  /**\n   * Use this one for anything that needs to validate asynchronously.\n   * Pretty much exactly the same as the validators api, except it must be a function that returns a promise.\n   */\n  asyncValidators?: FormlyValidation<AsyncValidatorFn, Promise<boolean> | Observable<boolean>>;\n\n  /**\n   * Can be set instead of `type` to render custom html content.\n   */\n  template?: string;\n\n  /**\n   *  It is expected to be the name of the wrappers.\n   *  The formly field template will be wrapped by the first wrapper, then the second, then the third, etc.\n   *  You can also specify these as part of a type (which is the recommended approach).\n   */\n  wrappers?: (string | Type<FieldWrapper>)[];\n\n  /**\n   * Whether to hide the field. Defaults to false. If you wish this to be conditional use `expressions: { hide: ... }`\n   */\n  hide?: boolean;\n\n  /**\n   * Whether to reset the value on hide or not. Defaults to `true`.\n   */\n  resetOnHide?: boolean;\n\n  /**\n   * Conditionally hiding Field based on values from other Fields\n   * @deprecated use `expressions: { hide: ... }`\n   */\n  hideExpression?: boolean | string | ((model: any, formState: any, field?: FormlyFieldConfig) => boolean);\n\n  /**\n   * An object where the key is a property to be set on the main field config and the value is an expression used to assign that property.\n   * @deprecated use `expressions`\n   */\n  expressionProperties?: {\n    [property: string]: string | ((model: any, formState: any, field?: FormlyFieldConfig) => any) | Observable<any>;\n  };\n\n  /**\n   * An object where the key is a property to be set on the main field config and the value is an expression used to assign that property.\n   */\n  expressions?: FieldExpressions;\n\n  /**\n   * You can specify your own class that will be applied to the `formly-field` component.\n   */\n  className?: string;\n\n  /**\n   * Specify your own class that will be applied to the `formly-group` component.\n   */\n  fieldGroupClassName?: string;\n\n  /**\n   * A field group is a way to group fields together, making advanced layout very simple.\n   * It can also be used to group fields that are associated with the same model (useful if it's different than the model for the rest of the fields).\n   */\n  fieldGroup?: FormlyFieldConfig[];\n\n  fieldArray?: FormlyFieldConfig | ((field: FormlyFieldConfig) => FormlyFieldConfig);\n\n  /**\n   * Whether to focus or blur the element field. Defaults to false. If you wish this to be conditional use `expressions`\n   */\n  focus?: boolean;\n\n  /**\n   * An object with a few useful properties to control the model changes\n   * - `debounce`: integer value which contains the debounce model update value in milliseconds. A value of 0 triggers an immediate update.\n   * - `updateOn`: string event value that instructs when the control should be updated\n   */\n  modelOptions?: {\n    debounce?: {\n      default: number;\n    };\n    // @see https://angular.io/api/forms/AbstractControl#updateOn\n    updateOn?: 'change' | 'blur' | 'submit';\n  };\n\n  hooks?: FormlyHookConfig;\n\n  /**\n   * Array of functions to execute, as a pipeline, whenever the model updates, usually via user input.\n   */\n  parsers?: ((value: any) => any)[];\n\n  /**\n   * Returns child field by key name\n   */\n  get?: (key: FormlyFieldConfig['key']) => FormlyFieldConfig;\n\n  /**\n   * The model that stores all the data, where the model[key] is the value of the field\n   */\n  readonly model?: any;\n\n  /**\n   * The parent field.\n   */\n  readonly parent?: FormlyFieldConfig;\n\n  /**\n   * The form options.\n   */\n  readonly options?: FormlyFormOptions;\n\n  /**\n   * The parent form.\n   */\n  readonly form?: UntypedFormGroup | UntypedFormArray;\n\n  /**\n   * This is the [FormControl](https://angular.io/api/forms/FormControl) for the field.\n   * It provides you more control like running validators, calculating status, and resetting state.\n   */\n  readonly formControl?: AbstractControl;\n\n  /** @deprecated */\n  optionsTypes?: string[];\n}\n\nexport type FormlyAttributeEvent = (field: FormlyFieldConfig, event?: any) => void;\n\n/**  @deprecated */\nexport interface FormlyTemplateOptions extends FormlyFieldProps {\n  [additionalProperties: string]: any;\n}\n\nexport interface FormlyFieldProps {\n  type?: string;\n  label?: string;\n  placeholder?: string;\n  disabled?: boolean;\n  options?: any[] | Observable<any[]>;\n  rows?: number;\n  cols?: number;\n  description?: string;\n  hidden?: boolean;\n  max?: number;\n  min?: number;\n\n  minLength?: number;\n  /** @deprecated use `minLength` */\n  minlength?: number;\n\n  maxLength?: number;\n  /** @deprecated use `maxLength` */\n  maxlength?: number;\n\n  pattern?: string | RegExp;\n  required?: boolean;\n  tabindex?: number;\n  readonly?: boolean;\n  attributes?: { [key: string]: string | number };\n  step?: number;\n  focus?: FormlyAttributeEvent;\n  blur?: FormlyAttributeEvent;\n  keyup?: FormlyAttributeEvent;\n  keydown?: FormlyAttributeEvent;\n  click?: FormlyAttributeEvent;\n  change?: FormlyAttributeEvent;\n  keypress?: FormlyAttributeEvent;\n  wheel?: FormlyAttributeEvent;\n}\n\nexport type FormlyHookFn = (field: FormlyFieldConfig) => void;\n\nexport interface FormlyHookConfig {\n  onInit?: FormlyHookFn | ((field: FormlyFieldConfig) => Observable<any>);\n  onChanges?: FormlyHookFn;\n  afterContentInit?: FormlyHookFn;\n  afterViewInit?: FormlyHookFn;\n  onDestroy?: FormlyHookFn;\n}\n\nexport interface FormlyFormOptions {\n  updateInitialValue?: (model?: any) => void;\n  resetModel?: (model?: any) => void;\n  formState?: any;\n  fieldChanges?: Subject<FormlyValueChangeEvent>;\n  showError?: (field: FieldType) => boolean;\n  build?: (field?: FormlyFieldConfig) => FormlyFieldConfig;\n  checkExpressions?: (field: FormlyFieldConfig) => void;\n  detectChanges?: (field: FormlyFieldConfig) => void;\n  parentForm?: FormGroupDirective | null;\n}\n\nexport interface FormlyValueChangeEvent {\n  field: FormlyFieldConfig;\n  type: string;\n  value: any;\n  [meta: string]: any;\n}\n\ninterface FormlyValidation<T, R> {\n  validation?: (string | T)[] | any;\n  [key: string]: FormlyValidatorFn<R> | FormlyValidatorExpressionFn<R> | any;\n}\ntype FormlyValidatorFn<T> = (control: AbstractControl, field: FormlyFieldConfig) => T;\n\ninterface FormlyValidatorExpressionFn<T> {\n  expression: FormlyValidatorFn<T>;\n  message: string | ((error: any, field: FormlyFieldConfig) => string | Observable<string>);\n}\n"]}

package/esm2022/lib/services/formly.builder.mjs

@@ -0,0 +1,100 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { defineHiddenProp, observe, disableTreeValidityCall, isHiddenField, isSignalRequired } from '../utils';
+import { FORMLY_CONFIG } from '../core.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./formly.config";
+import * as i2 from "@angular/forms";
+export class FormlyFormBuilder {
+    constructor(config, injector, viewContainerRef, parentForm, configs = []) {
+        this.config = config;
+        this.injector = injector;
+        this.viewContainerRef = viewContainerRef;
+        this.parentForm = parentForm;
+        configs.forEach((c) => config.addConfig(c));
+    }
+    buildForm(form, fieldGroup = [], model, options) {
+        this.build({ fieldGroup, model, form, options });
+    }
+    build(field) {
+        if (!this.config.extensions.core) {
+            throw new Error('NgxFormly: missing `forRoot()` call. use `forRoot()` when registering the `FormlyModule`.');
+        }
+        if (!field.parent) {
+            this._setOptions(field);
+        }
+        disableTreeValidityCall(field.form, () => {
+            this._build(field);
+            // TODO: add test for https://github.com/ngx-formly/ngx-formly/issues/3910
+            if (!field.parent || field.fieldArray) {
+                // detect changes early to avoid reset value by hidden fields
+                const options = field.options;
+                if (field.parent && isHiddenField(field)) {
+                    // when hide is used in expression set defaul value will not be set until detect hide changes
+                    // which causes default value not set on new item is added
+                    options._hiddenFieldsForCheck?.push({ field, default: false });
+                }
+                options.checkExpressions?.(field, true);
+                options._detectChanges?.(field);
+            }
+        });
+    }
+    _build(field) {
+        if (!field) {
+            return;
+        }
+        const extensions = Object.values(this.config.extensions);
+        extensions.forEach((extension) => extension.prePopulate?.(field));
+        extensions.forEach((extension) => extension.onPopulate?.(field));
+        field.fieldGroup?.forEach((f) => this._build(f));
+        extensions.forEach((extension) => extension.postPopulate?.(field));
+    }
+    _setOptions(field) {
+        field.form = field.form || new UntypedFormGroup({});
+        field.model = field.model || {};
+        field.options = field.options || {};
+        const options = field.options;
+        if (!options._viewContainerRef) {
+            defineHiddenProp(options, '_viewContainerRef', this.viewContainerRef);
+        }
+        if (!options._injector) {
+            defineHiddenProp(options, '_injector', this.injector);
+        }
+        if (!options.build) {
+            options._buildForm = () => {
+                console.warn(`Formly: 'options._buildForm' is deprecated since v6.0, use 'options.build' instead.`);
+                this.build(field);
+            };
+            options.build = (f = field) => {
+                this.build(f);
+                return f;
+            };
+        }
+        if (!options.parentForm && this.parentForm) {
+            defineHiddenProp(options, 'parentForm', this.parentForm);
+            if (!isSignalRequired()) {
+                observe(options, ['parentForm', 'submitted'], ({ firstChange }) => {
+                    if (!firstChange) {
+                        options.detectChanges(field);
+                    }
+                });
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, deps: [{ token: i1.FormlyConfig }, { token: i0.Injector }, { token: i0.ViewContainerRef, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: FORMLY_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFormBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.FormlyConfig }, { type: i0.Injector }, { type: i0.ViewContainerRef, decorators: [{
+                    type: Optional
+                }] }, { type: i2.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FORMLY_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.builder.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/services/formly.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Injector, Optional, ViewContainerRef } from '@angular/core';\nimport { UntypedFormGroup, UntypedFormArray, FormGroupDirective } from '@angular/forms';\nimport { FormlyConfig } from './formly.config';\nimport { FormlyFieldConfig, FormlyFormOptions, FormlyFieldConfigCache, ConfigOption } from '../models';\nimport { defineHiddenProp, observe, disableTreeValidityCall, isHiddenField, isSignalRequired } from '../utils';\nimport { FORMLY_CONFIG } from '../core.config';\n\n@Injectable({ providedIn: 'root' })\nexport class FormlyFormBuilder {\n  constructor(\n    private config: FormlyConfig,\n    private injector: Injector,\n    @Optional() private viewContainerRef: ViewContainerRef,\n    @Optional() private parentForm: FormGroupDirective,\n    @Optional() @Inject(FORMLY_CONFIG) configs: ConfigOption[] = [],\n  ) {\n    configs.forEach((c) => config.addConfig(c));\n  }\n\n  buildForm(\n    form: UntypedFormGroup | UntypedFormArray,\n    fieldGroup: FormlyFieldConfig[] = [],\n    model: any,\n    options: FormlyFormOptions,\n  ) {\n    this.build({ fieldGroup, model, form, options });\n  }\n\n  build(field: FormlyFieldConfig) {\n    if (!this.config.extensions.core) {\n      throw new Error('NgxFormly: missing `forRoot()` call. use `forRoot()` when registering the `FormlyModule`.');\n    }\n\n    if (!field.parent) {\n      this._setOptions(field);\n    }\n\n    disableTreeValidityCall(field.form, () => {\n      this._build(field);\n      // TODO: add test for https://github.com/ngx-formly/ngx-formly/issues/3910\n      if (!field.parent || (field as FormlyFieldConfigCache).fieldArray) {\n        // detect changes early to avoid reset value by hidden fields\n        const options = (field as FormlyFieldConfigCache).options;\n\n        if (field.parent && isHiddenField(field)) {\n          // when hide is used in expression set defaul value will not be set until detect hide changes\n          // which causes default value not set on new item is added\n          options._hiddenFieldsForCheck?.push({ field, default: false });\n        }\n\n        options.checkExpressions?.(field, true);\n        options._detectChanges?.(field);\n      }\n    });\n  }\n\n  private _build(field: FormlyFieldConfigCache) {\n    if (!field) {\n      return;\n    }\n\n    const extensions = Object.values(this.config.extensions);\n    extensions.forEach((extension) => extension.prePopulate?.(field));\n    extensions.forEach((extension) => extension.onPopulate?.(field));\n    field.fieldGroup?.forEach((f) => this._build(f));\n    extensions.forEach((extension) => extension.postPopulate?.(field));\n  }\n\n  private _setOptions(field: FormlyFieldConfigCache) {\n    field.form = field.form || new UntypedFormGroup({});\n    field.model = field.model || {};\n    field.options = field.options || {};\n    const options = field.options;\n\n    if (!options._viewContainerRef) {\n      defineHiddenProp(options, '_viewContainerRef', this.viewContainerRef);\n    }\n\n    if (!options._injector) {\n      defineHiddenProp(options, '_injector', this.injector);\n    }\n\n    if (!options.build) {\n      options._buildForm = () => {\n        console.warn(`Formly: 'options._buildForm' is deprecated since v6.0, use 'options.build' instead.`);\n        this.build(field);\n      };\n\n      options.build = (f: FormlyFieldConfig = field) => {\n        this.build(f);\n\n        return f;\n      };\n    }\n\n    if (!options.parentForm && this.parentForm) {\n      defineHiddenProp(options, 'parentForm', this.parentForm);\n\n      if (!isSignalRequired()) {\n        observe(options, ['parentForm', 'submitted'], ({ firstChange }) => {\n          if (!firstChange) {\n            options.detectChanges(field);\n          }\n        });\n      }\n    }\n  }\n}\n"]}