@ngx-formly/core 6.3.11 → 7.0.0-alpha.0

package/esm2022/lib/core.mjs

@@ -0,0 +1,20 @@
+export { provideFormlyCore, provideFormlyConfig, FORMLY_CONFIG } from './core.config';
+export { LegacyFormlyForm, FormlyForm } from './components/formly.form';
+export { LegacyFormlyField, FormlyField } from './components/formly.field';
+export { FormlyAttributes as ɵFormlyAttributes } from './templates/formly.attributes';
+export { FormlyGroup as ɵFormlyGroup } from './templates/formly.group';
+export { FormlyTemplate as ɵFormlyTemplate } from './components/formly.template';
+export { FormlyValidationMessage as ɵFormlyValidationMessage } from './templates/formly.validation-message';
+export { FormlyConfig } from './services/formly.config';
+export { FormlyFormBuilder } from './services/formly.builder';
+export { FieldType } from './templates/field.type';
+export { FieldArrayType } from './templates/field-array.type';
+export { FieldWrapper } from './templates/field.wrapper';
+export { FormlyModule } from './core.module';
+export { defineHiddenProp as ɵdefineHiddenProp } from './utils';
+export { reverseDeepMerge as ɵreverseDeepMerge } from './utils';
+export { getFieldValue as ɵgetFieldValue } from './utils';
+export { clone as ɵclone } from './utils';
+export { observe as ɵobserve } from './utils';
+export { hasKey as ɵhasKey } from './utils';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core.module.mjs

@@ -0,0 +1,74 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LegacyFormlyForm } from './components/formly.form';
+import { LegacyFormlyField } from './components/formly.field';
+import { FormlyAttributes } from './templates/formly.attributes';
+import { FormlyConfig } from './services/formly.config';
+import { FormlyFormBuilder } from './services/formly.builder';
+import { FormlyGroup } from './templates/formly.group';
+import { FormlyValidationMessage } from './templates/formly.validation-message';
+import { FormlyTemplateType } from './templates/field-template.type';
+import { FormlyTemplate } from './components/formly.template';
+import { FORMLY_CONFIG, withDefaultConfig } from './core.config';
+import * as i0 from "@angular/core";
+export class FormlyModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: FormlyModule,
+            providers: [
+                { provide: FORMLY_CONFIG, multi: true, useFactory: withDefaultConfig, deps: [FormlyConfig] },
+                { provide: FORMLY_CONFIG, useValue: config, multi: true },
+                FormlyConfig,
+                FormlyFormBuilder,
+            ],
+        };
+    }
+    static forChild(config = {}) {
+        return {
+            ngModule: FormlyModule,
+            providers: [
+                { provide: FORMLY_CONFIG, multi: true, useFactory: withDefaultConfig, deps: [FormlyConfig] },
+                { provide: FORMLY_CONFIG, useValue: config, multi: true },
+                FormlyFormBuilder,
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: FormlyModule, declarations: [FormlyTemplate,
+            LegacyFormlyForm,
+            LegacyFormlyField,
+            FormlyAttributes,
+            FormlyGroup,
+            FormlyValidationMessage,
+            FormlyTemplateType], imports: [CommonModule], exports: [FormlyTemplate,
+            LegacyFormlyForm,
+            LegacyFormlyField,
+            FormlyAttributes,
+            FormlyGroup,
+            FormlyValidationMessage] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        FormlyTemplate,
+                        LegacyFormlyForm,
+                        LegacyFormlyField,
+                        FormlyAttributes,
+                        FormlyGroup,
+                        FormlyValidationMessage,
+                        FormlyTemplateType,
+                    ],
+                    exports: [
+                        FormlyTemplate,
+                        LegacyFormlyForm,
+                        LegacyFormlyField,
+                        FormlyAttributes,
+                        FormlyGroup,
+                        FormlyValidationMessage,
+                    ],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extensions/core/core.mjs

@@ -0,0 +1,148 @@
+import { ComponentRef } from '@angular/core';
+import { getFieldId, assignFieldValue, isUndefined, getFieldValue, reverseDeepMerge, defineHiddenProp, clone, getField, markFieldForCheck, hasKey, observe, isHiddenField, isSignalRequired, } from '../../utils';
+import { Subject } from 'rxjs';
+export class CoreExtension {
+    constructor(config) {
+        this.config = config;
+        this.formId = 0;
+    }
+    prePopulate(field) {
+        const root = field.parent;
+        this.initRootOptions(field);
+        this.initFieldProps(field);
+        if (root) {
+            Object.defineProperty(field, 'options', { get: () => root.options, configurable: true });
+            Object.defineProperty(field, 'model', {
+                get: () => (hasKey(field) && field.fieldGroup ? getFieldValue(field) : root.model),
+                configurable: true,
+            });
+        }
+        Object.defineProperty(field, 'get', {
+            value: (key) => getField(field, key),
+            configurable: true,
+        });
+        this.getFieldComponentInstance(field).prePopulate?.(field);
+    }
+    onPopulate(field) {
+        this.initFieldOptions(field);
+        this.getFieldComponentInstance(field).onPopulate?.(field);
+        if (field.fieldGroup) {
+            field.fieldGroup.forEach((f, index) => {
+                if (f) {
+                    Object.defineProperty(f, 'parent', { get: () => field, configurable: true });
+                    Object.defineProperty(f, 'index', { get: () => index, configurable: true });
+                }
+                this.formId++;
+            });
+        }
+    }
+    postPopulate(field) {
+        this.getFieldComponentInstance(field).postPopulate?.(field);
+    }
+    initFieldProps(field) {
+        field.props ??= field.templateOptions;
+        Object.defineProperty(field, 'templateOptions', {
+            get: () => field.props,
+            set: (props) => (field.props = props),
+            configurable: true,
+        });
+    }
+    initRootOptions(field) {
+        if (field.parent) {
+            return;
+        }
+        const options = field.options;
+        field.options.formState = field.options.formState || {};
+        if (!options.showError) {
+            options.showError = this.config.extras.showError;
+        }
+        if (!options.fieldChanges) {
+            defineHiddenProp(options, 'fieldChanges', new Subject());
+        }
+        if (!options._hiddenFieldsForCheck) {
+            options._hiddenFieldsForCheck = [];
+        }
+        options._markForCheck = (f) => {
+            console.warn(`Formly: 'options._markForCheck' is deprecated since v6.0, use 'options.detectChanges' instead.`);
+            options.detectChanges(f);
+        };
+        options._detectChanges = (f) => {
+            if (f._componentRefs) {
+                markFieldForCheck(f);
+            }
+            f.fieldGroup?.forEach((f) => f && options._detectChanges(f));
+        };
+        options.detectChanges = (f) => {
+            f.options.checkExpressions?.(f);
+            options._detectChanges(f);
+        };
+        options.resetModel = (model) => {
+            model = clone(model ?? options._initialModel);
+            if (field.model) {
+                Object.keys(field.model).forEach((k) => delete field.model[k]);
+                Object.assign(field.model, model || {});
+            }
+            if (!isSignalRequired()) {
+                observe(options, ['parentForm', 'submitted']).setValue(false, false);
+            }
+            options.build(field);
+            field.form.reset(field.model);
+        };
+        options.updateInitialValue = (model) => (options._initialModel = clone(model ?? field.model));
+        field.options.updateInitialValue();
+    }
+    initFieldOptions(field) {
+        reverseDeepMerge(field, {
+            id: getFieldId(`formly_${this.formId}`, field, field.index),
+            hooks: {},
+            modelOptions: {},
+            validation: { messages: {} },
+            props: !field.type || !hasKey(field)
+                ? {}
+                : {
+                    label: '',
+                    placeholder: '',
+                    disabled: false,
+                },
+        });
+        if (this.config.extras.resetFieldOnHide && field.resetOnHide !== false) {
+            field.resetOnHide = true;
+        }
+        if (field.type !== 'formly-template' &&
+            (field.template || field.expressions?.template || field.expressionProperties?.template)) {
+            field.type = 'formly-template';
+        }
+        if (!field.type && field.fieldGroup) {
+            field.type = 'formly-group';
+        }
+        if (field.type) {
+            this.config.getMergedField(field);
+        }
+        if (hasKey(field) &&
+            !isUndefined(field.defaultValue) &&
+            isUndefined(getFieldValue(field)) &&
+            !isHiddenField(field)) {
+            assignFieldValue(field, field.defaultValue);
+        }
+        field.wrappers = field.wrappers || [];
+    }
+    getFieldComponentInstance(field) {
+        const componentRefInstance = () => {
+            let componentRef = this.config.resolveFieldTypeRef(field);
+            const fieldComponentRef = field._componentRefs?.slice(-1)[0];
+            if (fieldComponentRef instanceof ComponentRef &&
+                fieldComponentRef?.componentType === componentRef?.componentType) {
+                componentRef = fieldComponentRef;
+            }
+            return componentRef?.instance;
+        };
+        if (!field._proxyInstance) {
+            defineHiddenProp(field, '_proxyInstance', new Proxy({}, {
+                get: (_, prop) => componentRefInstance()?.[prop],
+                set: (_, prop, value) => (componentRefInstance()[prop] = value),
+            }));
+        }
+        return field._proxyInstance;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../../../../../src/core/src/lib/extensions/core/core.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\nimport { FormlyConfig } from '../../services/formly.config';\nimport { FormlyFieldConfigCache, FormlyValueChangeEvent, FormlyExtension, FormlyFieldConfig } from '../../models';\nimport {\n  getFieldId,\n  assignFieldValue,\n  isUndefined,\n  getFieldValue,\n  reverseDeepMerge,\n  defineHiddenProp,\n  clone,\n  getField,\n  markFieldForCheck,\n  hasKey,\n  observe,\n  isHiddenField,\n  isSignalRequired,\n} from '../../utils';\nimport { Subject } from 'rxjs';\n\nexport class CoreExtension implements FormlyExtension {\n  private formId = 0;\n  constructor(private config: FormlyConfig) {}\n\n  prePopulate(field: FormlyFieldConfigCache) {\n    const root = field.parent;\n    this.initRootOptions(field);\n    this.initFieldProps(field);\n    if (root) {\n      Object.defineProperty(field, 'options', { get: () => root.options, configurable: true });\n      Object.defineProperty(field, 'model', {\n        get: () => (hasKey(field) && field.fieldGroup ? getFieldValue(field) : root.model),\n        configurable: true,\n      });\n    }\n\n    Object.defineProperty(field, 'get', {\n      value: (key: FormlyFieldConfig['key']) => getField(field, key),\n      configurable: true,\n    });\n\n    this.getFieldComponentInstance(field).prePopulate?.(field);\n  }\n\n  onPopulate(field: FormlyFieldConfigCache) {\n    this.initFieldOptions(field);\n    this.getFieldComponentInstance(field).onPopulate?.(field);\n    if (field.fieldGroup) {\n      field.fieldGroup.forEach((f, index) => {\n        if (f) {\n          Object.defineProperty(f, 'parent', { get: () => field, configurable: true });\n          Object.defineProperty(f, 'index', { get: () => index, configurable: true });\n        }\n        this.formId++;\n      });\n    }\n  }\n\n  postPopulate(field: FormlyFieldConfigCache) {\n    this.getFieldComponentInstance(field).postPopulate?.(field);\n  }\n\n  private initFieldProps(field: FormlyFieldConfigCache) {\n    field.props ??= field.templateOptions;\n    Object.defineProperty(field, 'templateOptions', {\n      get: () => field.props,\n      set: (props) => (field.props = props),\n      configurable: true,\n    });\n  }\n\n  private initRootOptions(field: FormlyFieldConfigCache) {\n    if (field.parent) {\n      return;\n    }\n\n    const options = field.options;\n    field.options.formState = field.options.formState || {};\n    if (!options.showError) {\n      options.showError = this.config.extras.showError;\n    }\n\n    if (!options.fieldChanges) {\n      defineHiddenProp(options, 'fieldChanges', new Subject<FormlyValueChangeEvent>());\n    }\n\n    if (!options._hiddenFieldsForCheck) {\n      options._hiddenFieldsForCheck = [];\n    }\n\n    options._markForCheck = (f) => {\n      console.warn(`Formly: 'options._markForCheck' is deprecated since v6.0, use 'options.detectChanges' instead.`);\n      options.detectChanges(f);\n    };\n\n    options._detectChanges = (f: FormlyFieldConfigCache) => {\n      if (f._componentRefs) {\n        markFieldForCheck(f);\n      }\n\n      f.fieldGroup?.forEach((f) => f && options._detectChanges(f));\n    };\n\n    options.detectChanges = (f: FormlyFieldConfigCache) => {\n      f.options.checkExpressions?.(f);\n      options._detectChanges(f);\n    };\n\n    options.resetModel = (model?: any) => {\n      model = clone(model ?? options._initialModel);\n      if (field.model) {\n        Object.keys(field.model).forEach((k) => delete field.model[k]);\n        Object.assign(field.model, model || {});\n      }\n\n      if (!isSignalRequired()) {\n        observe(options, ['parentForm', 'submitted']).setValue(false, false);\n      }\n      options.build(field);\n      field.form.reset(field.model);\n    };\n\n    options.updateInitialValue = (model?: any) => (options._initialModel = clone(model ?? field.model));\n    field.options.updateInitialValue();\n  }\n\n  private initFieldOptions(field: FormlyFieldConfigCache) {\n    reverseDeepMerge(field, {\n      id: getFieldId(`formly_${this.formId}`, field, field.index),\n      hooks: {},\n      modelOptions: {},\n      validation: { messages: {} },\n      props:\n        !field.type || !hasKey(field)\n          ? {}\n          : {\n              label: '',\n              placeholder: '',\n              disabled: false,\n            },\n    });\n\n    if (this.config.extras.resetFieldOnHide && field.resetOnHide !== false) {\n      field.resetOnHide = true;\n    }\n\n    if (\n      field.type !== 'formly-template' &&\n      (field.template || field.expressions?.template || field.expressionProperties?.template)\n    ) {\n      field.type = 'formly-template';\n    }\n\n    if (!field.type && field.fieldGroup) {\n      field.type = 'formly-group';\n    }\n\n    if (field.type) {\n      this.config.getMergedField(field);\n    }\n\n    if (\n      hasKey(field) &&\n      !isUndefined(field.defaultValue) &&\n      isUndefined(getFieldValue(field)) &&\n      !isHiddenField(field)\n    ) {\n      assignFieldValue(field, field.defaultValue);\n    }\n\n    field.wrappers = field.wrappers || [];\n  }\n\n  private getFieldComponentInstance(field: FormlyFieldConfigCache) {\n    const componentRefInstance = () => {\n      let componentRef = this.config.resolveFieldTypeRef(field);\n\n      const fieldComponentRef = field._componentRefs?.slice(-1)[0];\n      if (\n        fieldComponentRef instanceof ComponentRef &&\n        fieldComponentRef?.componentType === componentRef?.componentType\n      ) {\n        componentRef = fieldComponentRef as any;\n      }\n\n      return componentRef?.instance as any;\n    };\n\n    if (!field._proxyInstance) {\n      defineHiddenProp(\n        field,\n        '_proxyInstance',\n        new Proxy({} as FormlyExtension, {\n          get: (_, prop) => componentRefInstance()?.[prop],\n          set: (_, prop, value) => (componentRefInstance()[prop] = value),\n        }),\n      );\n    }\n\n    return field._proxyInstance;\n  }\n}\n"]}

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

@@ -0,0 +1,250 @@
+import { isObject, isNil, isUndefined, isFunction, defineHiddenProp, observe, getFieldValue, assignFieldValue, hasKey, } from '../../utils';
+import { evalExpression, evalStringExpression } from './utils';
+import { isObservable, Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { unregisterControl, registerControl, updateValidity } from '../field-form/utils';
+import { UntypedFormArray } from '@angular/forms';
+export class FieldExpressionExtension {
+    onPopulate(field) {
+        if (field._expressions) {
+            return;
+        }
+        // cache built expression
+        defineHiddenProp(field, '_expressions', {});
+        observe(field, ['hide'], ({ currentValue, firstChange }) => {
+            defineHiddenProp(field, '_hide', !!currentValue);
+            if (!firstChange || (firstChange && currentValue === true)) {
+                field.props.hidden = currentValue;
+                field.options._hiddenFieldsForCheck.push({ field });
+            }
+        });
+        if (field.hideExpression) {
+            observe(field, ['hideExpression'], ({ currentValue: expr }) => {
+                field._expressions.hide = this.parseExpressions(field, 'hide', typeof expr === 'boolean' ? () => expr : expr);
+            });
+        }
+        const evalExpr = (key, expr) => {
+            if (typeof expr === 'string' || isFunction(expr)) {
+                field._expressions[key] = this.parseExpressions(field, key, expr);
+            }
+            else if (expr instanceof Observable) {
+                field._expressions[key] = {
+                    value$: expr.pipe(tap((v) => {
+                        this.evalExpr(field, key, v);
+                        field.options._detectChanges(field);
+                    })),
+                };
+            }
+        };
+        field.expressions = field.expressions || {};
+        for (const key of Object.keys(field.expressions)) {
+            observe(field, ['expressions', key], ({ currentValue: expr }) => {
+                evalExpr(key, isFunction(expr) ? (...args) => expr(field, args[3]) : expr);
+            });
+        }
+        field.expressionProperties = field.expressionProperties || {};
+        for (const key of Object.keys(field.expressionProperties)) {
+            observe(field, ['expressionProperties', key], ({ currentValue }) => evalExpr(key, currentValue));
+        }
+    }
+    postPopulate(field) {
+        if (field.parent) {
+            return;
+        }
+        if (!field.options.checkExpressions) {
+            let checkLocked = false;
+            field.options.checkExpressions = (f, ignoreCache) => {
+                if (checkLocked) {
+                    return;
+                }
+                checkLocked = true;
+                const fieldChanged = this.checkExpressions(f, ignoreCache);
+                const options = field.options;
+                options._hiddenFieldsForCheck
+                    .sort((f) => (f.field.hide ? -1 : 1))
+                    .forEach((f) => this.changeHideState(f.field, f.field.hide ?? f.default, !ignoreCache));
+                options._hiddenFieldsForCheck = [];
+                if (fieldChanged) {
+                    this.checkExpressions(field);
+                }
+                checkLocked = false;
+            };
+            field.options._checkField = (f, ignoreCache) => {
+                console.warn(`Formly: 'options._checkField' is deprecated since v6.0, use 'options.checkExpressions' instead.`);
+                field.options.checkExpressions(f, ignoreCache);
+            };
+        }
+    }
+    parseExpressions(field, path, expr) {
+        let parentExpression;
+        if (field.parent && ['hide', 'props.disabled'].includes(path)) {
+            const rootValue = (f) => {
+                return path === 'hide' ? f.hide : f.props.disabled;
+            };
+            parentExpression = () => {
+                let root = field.parent;
+                while (root.parent && !rootValue(root)) {
+                    root = root.parent;
+                }
+                return rootValue(root);
+            };
+        }
+        expr = expr || (() => false);
+        if (typeof expr === 'string') {
+            expr = evalStringExpression(expr, ['model', 'formState', 'field']);
+        }
+        let currentValue;
+        return {
+            callback: (ignoreCache) => {
+                try {
+                    const exprValue = evalExpression(parentExpression ? (...args) => parentExpression(field) || expr(...args) : expr, { field }, [field.model, field.options.formState, field, ignoreCache]);
+                    if (ignoreCache ||
+                        (currentValue !== exprValue &&
+                            (!isObject(exprValue) ||
+                                isObservable(exprValue) ||
+                                JSON.stringify(exprValue) !== JSON.stringify(currentValue)))) {
+                        currentValue = exprValue;
+                        this.evalExpr(field, path, exprValue);
+                        return true;
+                    }
+                    return false;
+                }
+                catch (error) {
+                    error.message = `[Formly Error] [Expression "${path}"] ${error.message}`;
+                    throw error;
+                }
+            },
+        };
+    }
+    checkExpressions(field, ignoreCache = false) {
+        if (!field) {
+            return false;
+        }
+        let fieldChanged = false;
+        if (field._expressions) {
+            for (const key of Object.keys(field._expressions)) {
+                field._expressions[key].callback?.(ignoreCache) && (fieldChanged = true);
+            }
+        }
+        field.fieldGroup?.forEach((f) => this.checkExpressions(f, ignoreCache) && (fieldChanged = true));
+        return fieldChanged;
+    }
+    changeDisabledState(field, value) {
+        if (field.fieldGroup) {
+            field.fieldGroup
+                .filter((f) => !f._expressions.hasOwnProperty('props.disabled'))
+                .forEach((f) => this.changeDisabledState(f, value));
+        }
+        if (hasKey(field) && field.props.disabled !== value) {
+            field.props.disabled = value;
+        }
+    }
+    changeHideState(field, hide, resetOnHide) {
+        if (field.fieldGroup) {
+            field.fieldGroup
+                .filter((f) => f && !f._expressions.hide)
+                .forEach((f) => this.changeHideState(f, hide, resetOnHide));
+        }
+        if (field.formControl && hasKey(field)) {
+            defineHiddenProp(field, '_hide', !!(hide || field.hide));
+            const c = field.formControl;
+            if (c._fields?.length > 1) {
+                updateValidity(c);
+            }
+            if (hide === true && (!c._fields || c._fields.every((f) => !!f._hide))) {
+                unregisterControl(field, true);
+                if (resetOnHide && field.resetOnHide) {
+                    assignFieldValue(field, undefined);
+                    field.formControl.reset({ value: undefined, disabled: field.formControl.disabled });
+                    field.options.fieldChanges.next({ value: undefined, field, type: 'valueChanges' });
+                    if (field.fieldGroup && field.formControl instanceof UntypedFormArray) {
+                        field.fieldGroup.length = 0;
+                    }
+                }
+            }
+            else if (hide === false) {
+                if (field.resetOnHide && !isUndefined(field.defaultValue) && isUndefined(getFieldValue(field))) {
+                    assignFieldValue(field, field.defaultValue);
+                }
+                registerControl(field, undefined, true);
+                if (field.resetOnHide && field.fieldArray && field.fieldGroup?.length !== field.model?.length) {
+                    field.options.build(field);
+                }
+            }
+        }
+        if (field.options.fieldChanges) {
+            field.options.fieldChanges.next({ field, type: 'hidden', value: hide });
+        }
+    }
+    evalExpr(field, prop, value) {
+        if (prop.indexOf('model.') === 0) {
+            const key = prop.replace(/^model\./, ''), parent = field.fieldGroup ? field : field.parent;
+            let control = field?.key === key ? field.formControl : field.form.get(key);
+            if (!control && field.get(key)) {
+                control = field.get(key).formControl;
+            }
+            assignFieldValue({ key, parent, model: field.model }, value);
+            if (control && !(isNil(control.value) && isNil(value)) && control.value !== value) {
+                control.patchValue(value);
+            }
+        }
+        else {
+            try {
+                let target = field;
+                const paths = this._evalExpressionPath(field, prop);
+                const lastIndex = paths.length - 1;
+                for (let i = 0; i < lastIndex; i++) {
+                    target = target[paths[i]];
+                }
+                target[paths[lastIndex]] = value;
+            }
+            catch (error) {
+                error.message = `[Formly Error] [Expression "${prop}"] ${error.message}`;
+                throw error;
+            }
+            if (['templateOptions.disabled', 'props.disabled'].includes(prop) && hasKey(field)) {
+                this.changeDisabledState(field, value);
+            }
+        }
+        this.emitExpressionChanges(field, prop, value);
+    }
+    emitExpressionChanges(field, property, value) {
+        if (!field.options.fieldChanges) {
+            return;
+        }
+        field.options.fieldChanges.next({
+            field,
+            type: 'expressionChanges',
+            property,
+            value,
+        });
+    }
+    _evalExpressionPath(field, prop) {
+        if (field._expressions[prop] && field._expressions[prop].paths) {
+            return field._expressions[prop].paths;
+        }
+        let paths = [];
+        if (prop.indexOf('[') === -1) {
+            paths = prop.split('.');
+        }
+        else {
+            prop
+                .split(/[[\]]{1,2}/) // https://stackoverflow.com/a/20198206
+                .filter((p) => p)
+                .forEach((path) => {
+                const arrayPath = path.match(/['|"](.*?)['|"]/);
+                if (arrayPath) {
+                    paths.push(arrayPath[1]);
+                }
+                else {
+                    paths.push(...path.split('.').filter((p) => p));
+                }
+            });
+        }
+        if (field._expressions[prop]) {
+            field._expressions[prop].paths = paths;
+        }
+        return paths;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-expression.js","sourceRoot":"","sources":["../../../../../../../src/core/src/lib/extensions/field-expression/field-expression.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormlyValueChangeEvent, FormlyFieldConfigCache } from '../../models';\nimport {\n  isObject,\n  isNil,\n  isUndefined,\n  isFunction,\n  defineHiddenProp,\n  observe,\n  getFieldValue,\n  assignFieldValue,\n  hasKey,\n} from '../../utils';\nimport { evalExpression, evalStringExpression } from './utils';\nimport { isObservable, Observable } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport { FormlyExtension } from '../../models';\nimport { unregisterControl, registerControl, updateValidity } from '../field-form/utils';\nimport { UntypedFormArray } from '@angular/forms';\n\nexport class FieldExpressionExtension implements FormlyExtension {\n  onPopulate(field: FormlyFieldConfigCache) {\n    if (field._expressions) {\n      return;\n    }\n\n    // cache built expression\n    defineHiddenProp(field, '_expressions', {});\n\n    observe(field, ['hide'], ({ currentValue, firstChange }) => {\n      defineHiddenProp(field, '_hide', !!currentValue);\n      if (!firstChange || (firstChange && currentValue === true)) {\n        field.props.hidden = currentValue;\n        field.options._hiddenFieldsForCheck.push({ field });\n      }\n    });\n\n    if (field.hideExpression) {\n      observe(field, ['hideExpression'], ({ currentValue: expr }) => {\n        field._expressions.hide = this.parseExpressions(field, 'hide', typeof expr === 'boolean' ? () => expr : expr);\n      });\n    }\n\n    const evalExpr = (key: string, expr: any) => {\n      if (typeof expr === 'string' || isFunction(expr)) {\n        field._expressions[key] = this.parseExpressions(field, key, expr);\n      } else if (expr instanceof Observable) {\n        field._expressions[key] = {\n          value$: (expr as Observable<any>).pipe(\n            tap((v) => {\n              this.evalExpr(field, key, v);\n              field.options._detectChanges(field);\n            }),\n          ),\n        };\n      }\n    };\n\n    field.expressions = field.expressions || {};\n    for (const key of Object.keys(field.expressions)) {\n      observe(field, ['expressions', key], ({ currentValue: expr }) => {\n        evalExpr(key, isFunction(expr) ? (...args: any) => expr(field, args[3]) : expr);\n      });\n    }\n\n    field.expressionProperties = field.expressionProperties || {};\n    for (const key of Object.keys(field.expressionProperties)) {\n      observe(field, ['expressionProperties', key], ({ currentValue }) => evalExpr(key, currentValue));\n    }\n  }\n\n  postPopulate(field: FormlyFieldConfigCache) {\n    if (field.parent) {\n      return;\n    }\n\n    if (!field.options.checkExpressions) {\n      let checkLocked = false;\n      field.options.checkExpressions = (f, ignoreCache) => {\n        if (checkLocked) {\n          return;\n        }\n\n        checkLocked = true;\n        const fieldChanged = this.checkExpressions(f, ignoreCache);\n        const options = field.options;\n        options._hiddenFieldsForCheck\n          .sort((f) => (f.field.hide ? -1 : 1))\n          .forEach((f) => this.changeHideState(f.field, f.field.hide ?? f.default, !ignoreCache));\n        options._hiddenFieldsForCheck = [];\n        if (fieldChanged) {\n          this.checkExpressions(field);\n        }\n        checkLocked = false;\n      };\n      field.options._checkField = (f, ignoreCache) => {\n        console.warn(`Formly: 'options._checkField' is deprecated since v6.0, use 'options.checkExpressions' instead.`);\n        field.options.checkExpressions(f, ignoreCache);\n      };\n    }\n  }\n\n  private parseExpressions(field: FormlyFieldConfigCache, path: string, expr: any) {\n    let parentExpression: any;\n    if (field.parent && ['hide', 'props.disabled'].includes(path)) {\n      const rootValue = (f: FormlyFieldConfigCache) => {\n        return path === 'hide' ? f.hide : f.props.disabled;\n      };\n\n      parentExpression = () => {\n        let root = field.parent;\n        while (root.parent && !rootValue(root)) {\n          root = root.parent;\n        }\n\n        return rootValue(root);\n      };\n    }\n\n    expr = expr || (() => false);\n    if (typeof expr === 'string') {\n      expr = evalStringExpression(expr, ['model', 'formState', 'field']);\n    }\n\n    let currentValue: any;\n\n    return {\n      callback: (ignoreCache?: boolean) => {\n        try {\n          const exprValue = evalExpression(\n            parentExpression ? (...args: any) => parentExpression(field) || expr(...args) : expr,\n            { field },\n            [field.model, field.options.formState, field, ignoreCache],\n          );\n\n          if (\n            ignoreCache ||\n            (currentValue !== exprValue &&\n              (!isObject(exprValue) ||\n                isObservable(exprValue) ||\n                JSON.stringify(exprValue) !== JSON.stringify(currentValue)))\n          ) {\n            currentValue = exprValue;\n            this.evalExpr(field, path, exprValue);\n\n            return true;\n          }\n\n          return false;\n        } catch (error: any) {\n          error.message = `[Formly Error] [Expression \"${path}\"] ${error.message}`;\n          throw error;\n        }\n      },\n    };\n  }\n\n  private checkExpressions(field: FormlyFieldConfigCache, ignoreCache = false) {\n    if (!field) {\n      return false;\n    }\n\n    let fieldChanged = false;\n    if (field._expressions) {\n      for (const key of Object.keys(field._expressions)) {\n        field._expressions[key].callback?.(ignoreCache) && (fieldChanged = true);\n      }\n    }\n    field.fieldGroup?.forEach((f) => this.checkExpressions(f, ignoreCache) && (fieldChanged = true));\n\n    return fieldChanged;\n  }\n\n  private changeDisabledState(field: FormlyFieldConfigCache, value: boolean) {\n    if (field.fieldGroup) {\n      field.fieldGroup\n        .filter((f: FormlyFieldConfigCache) => !f._expressions.hasOwnProperty('props.disabled'))\n        .forEach((f) => this.changeDisabledState(f, value));\n    }\n\n    if (hasKey(field) && field.props.disabled !== value) {\n      field.props.disabled = value;\n    }\n  }\n\n  private changeHideState(field: FormlyFieldConfigCache, hide: boolean, resetOnHide: boolean) {\n    if (field.fieldGroup) {\n      field.fieldGroup\n        .filter((f: FormlyFieldConfigCache) => f && !f._expressions.hide)\n        .forEach((f) => this.changeHideState(f, hide, resetOnHide));\n    }\n\n    if (field.formControl && hasKey(field)) {\n      defineHiddenProp(field, '_hide', !!(hide || field.hide));\n      const c = field.formControl;\n      if (c._fields?.length > 1) {\n        updateValidity(c);\n      }\n\n      if (hide === true && (!c._fields || c._fields.every((f) => !!f._hide))) {\n        unregisterControl(field, true);\n        if (resetOnHide && field.resetOnHide) {\n          assignFieldValue(field, undefined);\n          field.formControl.reset({ value: undefined, disabled: field.formControl.disabled });\n          field.options.fieldChanges.next({ value: undefined, field, type: 'valueChanges' });\n          if (field.fieldGroup && field.formControl instanceof UntypedFormArray) {\n            field.fieldGroup.length = 0;\n          }\n        }\n      } else if (hide === false) {\n        if (field.resetOnHide && !isUndefined(field.defaultValue) && isUndefined(getFieldValue(field))) {\n          assignFieldValue(field, field.defaultValue);\n        }\n        registerControl(field, undefined, true);\n        if (field.resetOnHide && field.fieldArray && field.fieldGroup?.length !== field.model?.length) {\n          field.options.build(field);\n        }\n      }\n    }\n\n    if (field.options.fieldChanges) {\n      field.options.fieldChanges.next(<FormlyValueChangeEvent>{ field, type: 'hidden', value: hide });\n    }\n  }\n\n  private evalExpr(field: FormlyFieldConfigCache, prop: string, value: any) {\n    if (prop.indexOf('model.') === 0) {\n      const key = prop.replace(/^model\\./, ''),\n        parent = field.fieldGroup ? field : field.parent;\n\n      let control = field?.key === key ? field.formControl : field.form.get(key);\n      if (!control && field.get(key)) {\n        control = field.get(key).formControl;\n      }\n      assignFieldValue({ key, parent, model: field.model }, value);\n      if (control && !(isNil(control.value) && isNil(value)) && control.value !== value) {\n        control.patchValue(value);\n      }\n    } else {\n      try {\n        let target: any = field;\n        const paths = this._evalExpressionPath(field, prop);\n        const lastIndex = paths.length - 1;\n        for (let i = 0; i < lastIndex; i++) {\n          target = target[paths[i]];\n        }\n\n        target[paths[lastIndex]] = value;\n      } catch (error: any) {\n        error.message = `[Formly Error] [Expression \"${prop}\"] ${error.message}`;\n        throw error;\n      }\n\n      if (['templateOptions.disabled', 'props.disabled'].includes(prop) && hasKey(field)) {\n        this.changeDisabledState(field, value);\n      }\n    }\n\n    this.emitExpressionChanges(field, prop, value);\n  }\n\n  private emitExpressionChanges(field: FormlyFieldConfigCache, property: string, value: any) {\n    if (!field.options.fieldChanges) {\n      return;\n    }\n\n    field.options.fieldChanges.next({\n      field,\n      type: 'expressionChanges',\n      property,\n      value,\n    });\n  }\n\n  private _evalExpressionPath(field: FormlyFieldConfigCache, prop: string) {\n    if (field._expressions[prop] && field._expressions[prop].paths) {\n      return field._expressions[prop].paths;\n    }\n\n    let paths: string[] = [];\n    if (prop.indexOf('[') === -1) {\n      paths = prop.split('.');\n    } else {\n      prop\n        .split(/[[\\]]{1,2}/) // https://stackoverflow.com/a/20198206\n        .filter((p) => p)\n        .forEach((path) => {\n          const arrayPath = path.match(/['|\"](.*?)['|\"]/);\n          if (arrayPath) {\n            paths.push(arrayPath[1]);\n          } else {\n            paths.push(...path.split('.').filter((p) => p));\n          }\n        });\n    }\n\n    if (field._expressions[prop]) {\n      field._expressions[prop].paths = paths;\n    }\n\n    return paths;\n  }\n}\n"]}

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

@@ -0,0 +1,17 @@
+export function evalStringExpression(expression, argNames) {
+    try {
+        return Function(...argNames, `return ${expression};`);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+export function evalExpression(expression, thisArg, argVal) {
+    if (typeof expression === 'function') {
+        return expression.apply(thisArg, argVal);
+    }
+    else {
+        return expression ? true : false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29yZS9zcmMvbGliL2V4dGVuc2lvbnMvZmllbGQtZXhwcmVzc2lvbi91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsb0JBQW9CLENBQUMsVUFBa0IsRUFBRSxRQUFrQjtJQUN6RSxJQUFJO1FBQ0YsT0FBTyxRQUFRLENBQUMsR0FBRyxRQUFRLEVBQUUsVUFBVSxVQUFVLEdBQUcsQ0FBUSxDQUFDO0tBQzlEO0lBQUMsT0FBTyxLQUFLLEVBQUU7UUFDZCxPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQ3RCO0FBQ0gsQ0FBQztBQUVELE1BQU0sVUFBVSxjQUFjLENBQzVCLFVBQXlELEVBQ3pELE9BQVksRUFDWixNQUFhO0lBRWIsSUFBSSxPQUFPLFVBQVUsS0FBSyxVQUFVLEVBQUU7UUFDcEMsT0FBTyxVQUFVLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztLQUMxQztTQUFNO1FBQ0wsT0FBTyxVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO0tBQ2xDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBldmFsU3RyaW5nRXhwcmVzc2lvbihleHByZXNzaW9uOiBzdHJpbmcsIGFyZ05hbWVzOiBzdHJpbmdbXSkge1xuICB0cnkge1xuICAgIHJldHVybiBGdW5jdGlvbiguLi5hcmdOYW1lcywgYHJldHVybiAke2V4cHJlc3Npb259O2ApIGFzIGFueTtcbiAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICBjb25zb2xlLmVycm9yKGVycm9yKTtcbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZXZhbEV4cHJlc3Npb24oXG4gIGV4cHJlc3Npb246IHN0cmluZyB8ICgoLi4udmFsdWU6IGFueVtdKSA9PiBhbnkpIHwgYm9vbGVhbixcbiAgdGhpc0FyZzogYW55LFxuICBhcmdWYWw6IGFueVtdLFxuKTogYW55IHtcbiAgaWYgKHR5cGVvZiBleHByZXNzaW9uID09PSAnZnVuY3Rpb24nKSB7XG4gICAgcmV0dXJuIGV4cHJlc3Npb24uYXBwbHkodGhpc0FyZywgYXJnVmFsKTtcbiAgfSBlbHNlIHtcbiAgICByZXR1cm4gZXhwcmVzc2lvbiA/IHRydWUgOiBmYWxzZTtcbiAgfVxufVxuIl19