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

package/esm2022/lib/components/formly.field.mjs

@@ -0,0 +1,292 @@
+import { Component, Input, ViewContainerRef, ViewChild, ComponentRef, Optional, } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { defineHiddenProp, observe, observeDeep, getFieldValue, assignFieldValue, isObject, markFieldForCheck, hasKey, isSignalRequired, } from '../utils';
+import { isObservable } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/formly.config";
+import * as i2 from "./formly.template";
+/**
+ * The `<formly-field>` component is used to render the UI widget (layout + type) of a given `field`.
+ */
+export class FormlyField {
+    get containerRef() {
+        return this.config.extras.renderFormlyFieldElement ? this.viewContainerRef : this.hostContainerRef;
+    }
+    get elementRef() {
+        if (this.config.extras.renderFormlyFieldElement) {
+            return this._elementRef;
+        }
+        if (this.componentRefs?.[0] instanceof ComponentRef) {
+            return this.componentRefs[0].location;
+        }
+        return null;
+    }
+    constructor(config, renderer, _elementRef, hostContainerRef, form) {
+        this.config = config;
+        this.renderer = renderer;
+        this._elementRef = _elementRef;
+        this.hostContainerRef = hostContainerRef;
+        this.form = form;
+        this.hostObservers = [];
+        this.componentRefs = [];
+        this.hooksObservers = [];
+        this.detectFieldBuild = false;
+        this.valueChangesUnsubscribe = () => { };
+    }
+    ngAfterContentInit() {
+        this.triggerHook('afterContentInit');
+    }
+    ngAfterViewInit() {
+        this.triggerHook('afterViewInit');
+    }
+    ngDoCheck() {
+        if (this.detectFieldBuild && this.field && this.field.options) {
+            this.render();
+        }
+    }
+    ngOnInit() {
+        this.triggerHook('onInit');
+    }
+    ngOnChanges(changes) {
+        this.triggerHook('onChanges', changes);
+    }
+    ngOnDestroy() {
+        this.resetRefs(this.field);
+        this.hostObservers.forEach((hostObserver) => hostObserver.unsubscribe());
+        this.hooksObservers.forEach((unsubscribe) => unsubscribe());
+        this.valueChangesUnsubscribe();
+        this.triggerHook('onDestroy');
+    }
+    renderField(containerRef, f, wrappers = []) {
+        if (this.containerRef === containerRef) {
+            this.resetRefs(this.field);
+            this.containerRef.clear();
+            wrappers = this.field?.wrappers;
+        }
+        if (wrappers?.length > 0) {
+            const [wrapper, ...wps] = wrappers;
+            const { component } = this.config.getWrapper(wrapper);
+            const ref = containerRef.createComponent(component);
+            this.attachComponentRef(ref, f);
+            observe(ref.instance, ['fieldComponent'], ({ currentValue, previousValue, firstChange }) => {
+                if (currentValue) {
+                    if (previousValue && previousValue._lContainer === currentValue._lContainer) {
+                        return;
+                    }
+                    const viewRef = previousValue ? previousValue.detach() : null;
+                    if (viewRef && !viewRef.destroyed) {
+                        currentValue.insert(viewRef);
+                    }
+                    else {
+                        this.renderField(currentValue, f, wps);
+                    }
+                    !firstChange && ref.changeDetectorRef.detectChanges();
+                }
+            });
+        }
+        else if (f?.type) {
+            const inlineType = this.form?.templates?.find((ref) => ref.name === f.type);
+            let ref;
+            if (inlineType) {
+                ref = containerRef.createEmbeddedView(inlineType.ref, { $implicit: f });
+            }
+            else {
+                const { component } = this.config.getType(f.type, true);
+                ref = containerRef.createComponent(component);
+            }
+            this.attachComponentRef(ref, f);
+        }
+    }
+    triggerHook(name, changes) {
+        if (name === 'onInit' || (name === 'onChanges' && changes.field && !changes.field.firstChange)) {
+            this.valueChangesUnsubscribe();
+            this.valueChangesUnsubscribe = this.fieldChanges(this.field);
+        }
+        if (this.field?.hooks?.[name]) {
+            if (!changes || changes.field) {
+                const r = this.field.hooks[name](this.field);
+                if (isObservable(r) && ['onInit', 'afterContentInit', 'afterViewInit'].indexOf(name) !== -1) {
+                    const sub = r.subscribe();
+                    this.hooksObservers.push(() => sub.unsubscribe());
+                }
+            }
+        }
+        if (name === 'onChanges' && changes.field) {
+            this.resetRefs(changes.field.previousValue);
+            this.render();
+        }
+    }
+    attachComponentRef(ref, field) {
+        this.componentRefs.push(ref);
+        field._componentRefs.push(ref);
+        if (ref instanceof ComponentRef) {
+            Object.assign(ref.instance, { field });
+        }
+    }
+    render() {
+        if (!this.field) {
+            return;
+        }
+        // require Formly build
+        if (!this.field.options) {
+            this.detectFieldBuild = true;
+            return;
+        }
+        this.detectFieldBuild = false;
+        this.hostObservers.forEach((hostObserver) => hostObserver.unsubscribe());
+        this.hostObservers = [
+            observe(this.field, ['hide'], ({ firstChange, currentValue }) => {
+                const containerRef = this.containerRef;
+                if (this.config.extras.lazyRender === false) {
+                    firstChange && this.renderField(containerRef, this.field);
+                    if (!firstChange || (firstChange && currentValue)) {
+                        this.elementRef &&
+                            this.renderer.setStyle(this.elementRef.nativeElement, 'display', currentValue ? 'none' : '');
+                    }
+                }
+                else {
+                    if (currentValue) {
+                        containerRef.clear();
+                        if (this.field.className) {
+                            this.renderer.removeAttribute(this.elementRef.nativeElement, 'class');
+                        }
+                    }
+                    else {
+                        this.renderField(containerRef, this.field);
+                        if (this.field.className) {
+                            this.renderer.setAttribute(this.elementRef.nativeElement, 'class', this.field.className);
+                        }
+                    }
+                }
+                !firstChange && this.field.options.detectChanges(this.field);
+            }),
+            observe(this.field, ['className'], ({ firstChange, currentValue }) => {
+                if ((!firstChange || (firstChange && currentValue)) &&
+                    (!this.config.extras.lazyRender || this.field.hide !== true)) {
+                    this.elementRef && this.renderer.setAttribute(this.elementRef.nativeElement, 'class', currentValue);
+                }
+            }),
+        ];
+        if (!isSignalRequired()) {
+            ['touched', 'pristine', 'status'].forEach((prop) => this.hostObservers.push(observe(this.field, ['formControl', prop], ({ firstChange }) => !firstChange && markFieldForCheck(this.field))));
+        }
+        else if (this.field.formControl) {
+            const events = this.field.formControl.events.subscribe(() => markFieldForCheck(this.field));
+            this.hostObservers.push(events);
+        }
+    }
+    resetRefs(field) {
+        if (field) {
+            if (field._localFields) {
+                field._localFields = [];
+            }
+            else {
+                defineHiddenProp(this.field, '_localFields', []);
+            }
+            if (field._componentRefs) {
+                field._componentRefs = field._componentRefs.filter((ref) => this.componentRefs.indexOf(ref) === -1);
+            }
+            else {
+                defineHiddenProp(this.field, '_componentRefs', []);
+            }
+        }
+        this.componentRefs = [];
+    }
+    fieldChanges(field) {
+        if (!field) {
+            return () => { };
+        }
+        const propsObserver = observeDeep(field, ['props'], () => field.options.detectChanges(field));
+        const subscribes = [
+            () => {
+                propsObserver();
+            },
+        ];
+        for (const key of Object.keys(field._expressions || {})) {
+            const expressionObserver = observe(field, ['_expressions', key], ({ currentValue, previousValue }) => {
+                if (previousValue?.subscription) {
+                    previousValue.subscription.unsubscribe();
+                    previousValue.subscription = null;
+                }
+                if (isObservable(currentValue.value$)) {
+                    currentValue.subscription = currentValue.value$.subscribe();
+                }
+            });
+            subscribes.push(() => {
+                if (field._expressions[key]?.subscription) {
+                    field._expressions[key].subscription.unsubscribe();
+                }
+                expressionObserver.unsubscribe();
+            });
+        }
+        for (const path of [['focus'], ['template'], ['fieldGroupClassName'], ['validation', 'show']]) {
+            const fieldObserver = observe(field, path, ({ firstChange }) => !firstChange && field.options.detectChanges(field));
+            subscribes.push(() => fieldObserver.unsubscribe());
+        }
+        if (field.formControl && !field.fieldGroup) {
+            const control = field.formControl;
+            let valueChanges = control.valueChanges.pipe(map((value) => {
+                field.parsers?.map((parserFn) => (value = parserFn(value, field)));
+                if (!Object.is(value, field.formControl.value)) {
+                    field.formControl.setValue(value);
+                }
+                return value;
+            }), distinctUntilChanged((x, y) => {
+                if (x !== y || Array.isArray(x) || isObject(x)) {
+                    return false;
+                }
+                return true;
+            }));
+            if (control.value !== getFieldValue(field)) {
+                valueChanges = valueChanges.pipe(startWith(control.value));
+            }
+            const { updateOn, debounce } = field.modelOptions;
+            if ((!updateOn || updateOn === 'change') && debounce?.default > 0) {
+                valueChanges = control.valueChanges.pipe(debounceTime(debounce.default));
+            }
+            const sub = valueChanges.subscribe((value) => {
+                // workaround for https://github.com/angular/angular/issues/13792
+                if (control._fields?.length > 1 && control instanceof FormControl) {
+                    control.patchValue(value, { emitEvent: false, onlySelf: true });
+                }
+                if (hasKey(field)) {
+                    assignFieldValue(field, value);
+                }
+                field.options.fieldChanges.next({ value, field, type: 'valueChanges' });
+            });
+            subscribes.push(() => sub.unsubscribe());
+        }
+        let templateFieldsSubs = [];
+        observe(field, ['_localFields'], ({ currentValue }) => {
+            templateFieldsSubs.forEach((unsubscribe) => unsubscribe());
+            templateFieldsSubs = (currentValue || []).map((f) => this.fieldChanges(f));
+        });
+        return () => {
+            subscribes.forEach((unsubscribe) => unsubscribe());
+            templateFieldsSubs.forEach((unsubscribe) => unsubscribe());
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyField, deps: [{ token: i1.FormlyConfig }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i2.FormlyFieldTemplates, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyField, isStandalone: true, selector: "formly-field", inputs: { field: "field" }, viewQueries: [{ propertyName: "viewContainerRef", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyField, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-field', template: '<ng-template #container></ng-template>', standalone: true, styles: [":host:empty{display:none}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormlyConfig }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i2.FormlyFieldTemplates, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { field: [{
+                type: Input
+            }], viewContainerRef: [{
+                type: ViewChild,
+                args: ['container', { read: ViewContainerRef, static: true }]
+            }] } });
+export class LegacyFormlyField extends FormlyField {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyField, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyField, selector: "formly-field", usesInheritance: true, ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true, styles: [":host:empty{display:none}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyField, decorators: [{
+            type: Component,
+            args: [{ selector: 'formly-field', template: '<ng-template #container></ng-template>', standalone: false, styles: [":host:empty{display:none}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.field.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/components/formly.field.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,gBAAgB,EAChB,SAAS,EACT,YAAY,EAWZ,QAAQ,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C,OAAO,EACL,gBAAgB,EAChB,OAAO,EACP,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,iBAAiB,EACjB,MAAM,EAEN,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAA4B,YAAY,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;;AAGpF;;GAEG;AAOH,MAAM,OAAO,WAAW;IAUtB,IAAY,YAAY;QACtB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACrG,CAAC;IAED,IAAY,UAAU;QACpB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC;YAChD,OAAO,IAAI,CAAC,WAAW,CAAC;QAC1B,CAAC;QACD,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,YAAY,YAAY,EAAE,CAAC;YACpD,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACxC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAID,YACU,MAAoB,EACpB,QAAmB,EACnB,WAAuB,EACvB,gBAAkC,EACtB,IAA0B;QAJtC,WAAM,GAAN,MAAM,CAAc;QACpB,aAAQ,GAAR,QAAQ,CAAW;QACnB,gBAAW,GAAX,WAAW,CAAY;QACvB,qBAAgB,GAAhB,gBAAgB,CAAkB;QACtB,SAAI,GAAJ,IAAI,CAAsB;QA3BxC,kBAAa,GAAsC,EAAE,CAAC;QACtD,kBAAa,GAA6D,EAAE,CAAC;QAC7E,mBAAc,GAAmB,EAAE,CAAC;QACpC,qBAAgB,GAAG,KAAK,CAAC;QAiBjC,4BAAuB,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAQhC,CAAC;IAEJ,kBAAkB;QAChB,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;IACvC,CAAC;IAED,eAAe;QACb,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;IACpC,CAAC;IAED,SAAS;QACP,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YAC9D,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAChC,CAAC;IAEO,WAAW,CACjB,YAA8B,EAC9B,CAAyB,EACzB,WAA0C,EAAE;QAE5C,IAAI,IAAI,CAAC,YAAY,KAAK,YAAY,EAAE,CAAC;YACvC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;YAC1B,QAAQ,GAAG,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC;QAClC,CAAC;QAED,IAAI,QAAQ,EAAE,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,GAAG,QAAQ,CAAC;YACnC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAEtD,MAAM,GAAG,GAAG,YAAY,CAAC,eAAe,CAAe,SAAS,CAAC,CAAC;YAClE,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAChC,OAAO,CACL,GAAG,CAAC,QAAQ,EACZ,CAAC,gBAAgB,CAAC,EAClB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,EAAE,EAAE;gBAC/C,IAAI,YAAY,EAAE,CAAC;oBACjB,IAAI,aAAa,IAAI,aAAa,CAAC,WAAW,KAAK,YAAY,CAAC,WAAW,EAAE,CAAC;wBAC5E,OAAO;oBACT,CAAC;oBAED,MAAM,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;oBAC9D,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;wBAClC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;oBAC/B,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;oBACzC,CAAC;oBAED,CAAC,WAAW,IAAI,GAAG,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;gBACxD,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC;aAAM,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;YACnB,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5E,IAAI,GAA6C,CAAC;YAClD,IAAI,UAAU,EAAE,CAAC;gBACf,GAAG,GAAG,YAAY,CAAC,kBAAkB,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;YAC1E,CAAC;iBAAM,CAAC;gBACN,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBACxD,GAAG,GAAG,YAAY,CAAC,eAAe,CAAe,SAAgB,CAAC,CAAC;YACrE,CAAC;YACD,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAEO,WAAW,CAAC,IAA4B,EAAE,OAAuB;QACvE,IAAI,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,OAAO,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/F,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;gBAC9B,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC7C,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;oBAC5F,MAAM,GAAG,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC;oBAC1B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;gBACpD,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,IAAI,KAAK,WAAW,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAC1C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAEO,kBAAkB,CACxB,GAAyC,EACzC,KAA6B;QAE7B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7B,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,GAAG,YAAY,YAAY,EAAE,CAAC;YAChC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QAED,uBAAuB;QACvB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAE7B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,aAAa,GAAG;YACnB,OAAO,CAAU,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,EAAE;gBACvE,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;gBACvC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;oBAC5C,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC1D,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,IAAI,YAAY,CAAC,EAAE,CAAC;wBAClD,IAAI,CAAC,UAAU;4BACb,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBACjG,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,YAAY,EAAE,CAAC;wBACjB,YAAY,CAAC,KAAK,EAAE,CAAC;wBACrB,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;4BACzB,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;wBACxE,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;wBAC3C,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;4BACzB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;wBAC3F,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,CAAC,WAAW,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/D,CAAC,CAAC;YACF,OAAO,CAAS,IAAI,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,EAAE;gBAC3E,IACE,CAAC,CAAC,WAAW,IAAI,CAAC,WAAW,IAAI,YAAY,CAAC,CAAC;oBAC/C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAC5D,CAAC;oBACD,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;gBACtG,CAAC;YACH,CAAC,CAAC;SACH,CAAC;QAEF,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC;YACxB,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CACjD,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,OAAO,CACL,IAAI,CAAC,KAAK,EACV,CAAC,aAAa,EAAE,IAAI,CAAC,EACrB,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,WAAW,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CACnE,CACF,CACF,CAAC;QACJ,CAAC;aAAM,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YAClC,MAAM,MAAM,GAAK,IAAI,CAAC,KAAK,CAAC,WAAmB,CAAC,MAA0B,CAAC,SAAS,CAAC,GAAG,EAAE,CACxF,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAC9B,CAAC;YACF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,KAA6B;QAC7C,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;gBACvB,KAAK,CAAC,YAAY,GAAG,EAAE,CAAC;YAC1B,CAAC;iBAAM,CAAC;gBACN,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;YACnD,CAAC;YAED,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;gBACzB,KAAK,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACtG,CAAC;iBAAM,CAAC;gBACN,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,EAAE,EAAE,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;IAC1B,CAAC;IAEO,YAAY,CAAC,KAAyC;QAC5D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;QAClB,CAAC;QAED,MAAM,aAAa,GAAG,WAAW,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9F,MAAM,UAAU,GAAG;YACjB,GAAG,EAAE;gBACH,aAAa,EAAE,CAAC;YAClB,CAAC;SACF,CAAC;QAEF,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC,EAAE,CAAC;YACxD,MAAM,kBAAkB,GAAG,OAAO,CAChC,KAAK,EACL,CAAC,cAAc,EAAE,GAAG,CAAC,EACrB,CAAC,EAAE,YAAY,EAAE,aAAa,EAAE,EAAE,EAAE;gBAClC,IAAI,aAAa,EAAE,YAAY,EAAE,CAAC;oBAChC,aAAa,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;oBACzC,aAAa,CAAC,YAAY,GAAG,IAAI,CAAC;gBACpC,CAAC;gBACD,IAAI,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;oBACtC,YAAY,CAAC,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC9D,CAAC;YACH,CAAC,CACF,CAAC;YACF,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE;gBACnB,IAAI,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC;oBAC1C,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;gBACrD,CAAC;gBACD,kBAAkB,CAAC,WAAW,EAAE,CAAC;YACnC,CAAC,CAAC,CAAC;QACL,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;YAC9F,MAAM,aAAa,GAAG,OAAO,CAC3B,KAAK,EACL,IAAI,EACJ,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CACxE,CAAC;YACF,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,KAAK,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,OAAO,GAAG,KAAK,CAAC,WAAW,CAAC;YAClC,IAAI,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAC1C,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;gBACZ,KAAK,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,KAAK,GAAI,QAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC5E,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC/C,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBACpC,CAAC;gBAED,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,EACF,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC/C,OAAO,KAAK,CAAC;gBACf,CAAC;gBAED,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CACH,CAAC;YAEF,IAAI,OAAO,CAAC,KAAK,KAAK,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,YAAY,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7D,CAAC;YAED,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,YAAY,CAAC;YAClD,IAAI,CAAC,CAAC,QAAQ,IAAI,QAAQ,KAAK,QAAQ,CAAC,IAAI,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC;gBAClE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC3E,CAAC;YAED,MAAM,GAAG,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC3C,iEAAiE;gBACjE,IAAI,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,IAAI,OAAO,YAAY,WAAW,EAAE,CAAC;oBAClE,OAAO,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;gBAClE,CAAC;gBAED,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;oBAClB,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBACjC,CAAC;gBACD,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;YAC1E,CAAC,CAAC,CAAC;YAEH,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,kBAAkB,GAAmB,EAAE,CAAC;QAC5C,OAAO,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE;YACpD,kBAAkB,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;YAC3D,kBAAkB,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAyB,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QACrG,CAAC,CAAC,CAAC;QAEH,OAAO,GAAG,EAAE;YACV,UAAU,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;YACnD,kBAAkB,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;QAC7D,CAAC,CAAC;IACJ,CAAC;+GA1UU,WAAW;mGAAX,WAAW,8LAGU,gBAAgB,gEAPtC,wCAAwC;;4FAIvC,WAAW;kBANvB,SAAS;+BACE,cAAc,YACd,wCAAwC,cAEtC,IAAI;;0BAkCb,QAAQ;yCA9BF,KAAK;sBAAb,KAAK;gBAC4D,gBAAgB;sBAAjF,SAAS;uBAAC,WAAW,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE;;AAgVlE,MAAM,OAAO,iBAAkB,SAAQ,WAAW;+GAArC,iBAAiB;mGAAjB,iBAAiB,2EAJlB,wCAAwC;;4FAIvC,iBAAiB;kBAN7B,SAAS;+BACE,cAAc,YACd,wCAAwC,cAEtC,KAAK","sourcesContent":["import {\n  Component,\n  Input,\n  ViewContainerRef,\n  ViewChild,\n  ComponentRef,\n  SimpleChanges,\n  DoCheck,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  AfterContentInit,\n  AfterViewInit,\n  Renderer2,\n  ElementRef,\n  EmbeddedViewRef,\n  Optional,\n} from '@angular/core';\nimport { FormControl } from '@angular/forms';\nimport { FormlyConfig } from '../services/formly.config';\nimport { FormlyFieldConfig, FormlyFieldConfigCache, FormlyHookConfig } from '../models';\nimport {\n  defineHiddenProp,\n  observe,\n  observeDeep,\n  getFieldValue,\n  assignFieldValue,\n  isObject,\n  markFieldForCheck,\n  hasKey,\n  IObserver,\n  isSignalRequired,\n} from '../utils';\nimport { FieldWrapper } from '../templates/field.wrapper';\nimport { FieldType } from '../templates/field.type';\nimport { Observable, Subscription, isObservable } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, map, startWith } from 'rxjs/operators';\nimport { FormlyFieldTemplates } from './formly.template';\n\n/**\n * The `<formly-field>` component is used to render the UI widget (layout + type) of a given `field`.\n */\n@Component({\n  selector: 'formly-field',\n  template: '<ng-template #container></ng-template>',\n  styleUrls: ['./formly.field.scss'],\n  standalone: true,\n})\nexport class FormlyField implements DoCheck, OnInit, OnChanges, AfterContentInit, AfterViewInit, OnDestroy {\n  /** The field config. */\n  @Input() field: FormlyFieldConfig;\n  @ViewChild('container', { read: ViewContainerRef, static: true }) viewContainerRef!: ViewContainerRef;\n\n  private hostObservers: (IObserver<any> | Subscription)[] = [];\n  private componentRefs: (ComponentRef<FieldType> | EmbeddedViewRef<FieldType>)[] = [];\n  private hooksObservers: (() => void)[] = [];\n  private detectFieldBuild = false;\n\n  private get containerRef() {\n    return this.config.extras.renderFormlyFieldElement ? this.viewContainerRef : this.hostContainerRef;\n  }\n\n  private get elementRef() {\n    if (this.config.extras.renderFormlyFieldElement) {\n      return this._elementRef;\n    }\n    if (this.componentRefs?.[0] instanceof ComponentRef) {\n      return this.componentRefs[0].location;\n    }\n\n    return null;\n  }\n\n  valueChangesUnsubscribe = () => {};\n\n  constructor(\n    private config: FormlyConfig,\n    private renderer: Renderer2,\n    private _elementRef: ElementRef,\n    private hostContainerRef: ViewContainerRef,\n    @Optional() private form: FormlyFieldTemplates,\n  ) {}\n\n  ngAfterContentInit() {\n    this.triggerHook('afterContentInit');\n  }\n\n  ngAfterViewInit() {\n    this.triggerHook('afterViewInit');\n  }\n\n  ngDoCheck() {\n    if (this.detectFieldBuild && this.field && this.field.options) {\n      this.render();\n    }\n  }\n\n  ngOnInit() {\n    this.triggerHook('onInit');\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.triggerHook('onChanges', changes);\n  }\n\n  ngOnDestroy() {\n    this.resetRefs(this.field);\n    this.hostObservers.forEach((hostObserver) => hostObserver.unsubscribe());\n    this.hooksObservers.forEach((unsubscribe) => unsubscribe());\n    this.valueChangesUnsubscribe();\n    this.triggerHook('onDestroy');\n  }\n\n  private renderField(\n    containerRef: ViewContainerRef,\n    f: FormlyFieldConfigCache,\n    wrappers: FormlyFieldConfig['wrappers'] = [],\n  ) {\n    if (this.containerRef === containerRef) {\n      this.resetRefs(this.field);\n      this.containerRef.clear();\n      wrappers = this.field?.wrappers;\n    }\n\n    if (wrappers?.length > 0) {\n      const [wrapper, ...wps] = wrappers;\n      const { component } = this.config.getWrapper(wrapper);\n\n      const ref = containerRef.createComponent<FieldWrapper>(component);\n      this.attachComponentRef(ref, f);\n      observe<ViewContainerRef & { _lContainer: any }>(\n        ref.instance,\n        ['fieldComponent'],\n        ({ currentValue, previousValue, firstChange }) => {\n          if (currentValue) {\n            if (previousValue && previousValue._lContainer === currentValue._lContainer) {\n              return;\n            }\n\n            const viewRef = previousValue ? previousValue.detach() : null;\n            if (viewRef && !viewRef.destroyed) {\n              currentValue.insert(viewRef);\n            } else {\n              this.renderField(currentValue, f, wps);\n            }\n\n            !firstChange && ref.changeDetectorRef.detectChanges();\n          }\n        },\n      );\n    } else if (f?.type) {\n      const inlineType = this.form?.templates?.find((ref) => ref.name === f.type);\n      let ref: ComponentRef<any> | EmbeddedViewRef<any>;\n      if (inlineType) {\n        ref = containerRef.createEmbeddedView(inlineType.ref, { $implicit: f });\n      } else {\n        const { component } = this.config.getType(f.type, true);\n        ref = containerRef.createComponent<FieldWrapper>(component as any);\n      }\n      this.attachComponentRef(ref, f);\n    }\n  }\n\n  private triggerHook(name: keyof FormlyHookConfig, changes?: SimpleChanges) {\n    if (name === 'onInit' || (name === 'onChanges' && changes.field && !changes.field.firstChange)) {\n      this.valueChangesUnsubscribe();\n      this.valueChangesUnsubscribe = this.fieldChanges(this.field);\n    }\n\n    if (this.field?.hooks?.[name]) {\n      if (!changes || changes.field) {\n        const r = this.field.hooks[name](this.field);\n        if (isObservable(r) && ['onInit', 'afterContentInit', 'afterViewInit'].indexOf(name) !== -1) {\n          const sub = r.subscribe();\n          this.hooksObservers.push(() => sub.unsubscribe());\n        }\n      }\n    }\n\n    if (name === 'onChanges' && changes.field) {\n      this.resetRefs(changes.field.previousValue);\n      this.render();\n    }\n  }\n\n  private attachComponentRef<T extends FieldType>(\n    ref: ComponentRef<T> | EmbeddedViewRef<T>,\n    field: FormlyFieldConfigCache,\n  ) {\n    this.componentRefs.push(ref);\n    field._componentRefs.push(ref);\n    if (ref instanceof ComponentRef) {\n      Object.assign(ref.instance, { field });\n    }\n  }\n\n  private render() {\n    if (!this.field) {\n      return;\n    }\n\n    // require Formly build\n    if (!this.field.options) {\n      this.detectFieldBuild = true;\n\n      return;\n    }\n\n    this.detectFieldBuild = false;\n    this.hostObservers.forEach((hostObserver) => hostObserver.unsubscribe());\n    this.hostObservers = [\n      observe<boolean>(this.field, ['hide'], ({ firstChange, currentValue }) => {\n        const containerRef = this.containerRef;\n        if (this.config.extras.lazyRender === false) {\n          firstChange && this.renderField(containerRef, this.field);\n          if (!firstChange || (firstChange && currentValue)) {\n            this.elementRef &&\n              this.renderer.setStyle(this.elementRef.nativeElement, 'display', currentValue ? 'none' : '');\n          }\n        } else {\n          if (currentValue) {\n            containerRef.clear();\n            if (this.field.className) {\n              this.renderer.removeAttribute(this.elementRef.nativeElement, 'class');\n            }\n          } else {\n            this.renderField(containerRef, this.field);\n            if (this.field.className) {\n              this.renderer.setAttribute(this.elementRef.nativeElement, 'class', this.field.className);\n            }\n          }\n        }\n\n        !firstChange && this.field.options.detectChanges(this.field);\n      }),\n      observe<string>(this.field, ['className'], ({ firstChange, currentValue }) => {\n        if (\n          (!firstChange || (firstChange && currentValue)) &&\n          (!this.config.extras.lazyRender || this.field.hide !== true)\n        ) {\n          this.elementRef && this.renderer.setAttribute(this.elementRef.nativeElement, 'class', currentValue);\n        }\n      }),\n    ];\n\n    if (!isSignalRequired()) {\n      ['touched', 'pristine', 'status'].forEach((prop) =>\n        this.hostObservers.push(\n          observe<string>(\n            this.field,\n            ['formControl', prop],\n            ({ firstChange }) => !firstChange && markFieldForCheck(this.field),\n          ),\n        ),\n      );\n    } else if (this.field.formControl) {\n      const events = ((this.field.formControl as any).events as Observable<any>).subscribe(() =>\n        markFieldForCheck(this.field),\n      );\n      this.hostObservers.push(events);\n    }\n  }\n\n  private resetRefs(field: FormlyFieldConfigCache) {\n    if (field) {\n      if (field._localFields) {\n        field._localFields = [];\n      } else {\n        defineHiddenProp(this.field, '_localFields', []);\n      }\n\n      if (field._componentRefs) {\n        field._componentRefs = field._componentRefs.filter((ref) => this.componentRefs.indexOf(ref) === -1);\n      } else {\n        defineHiddenProp(this.field, '_componentRefs', []);\n      }\n    }\n\n    this.componentRefs = [];\n  }\n\n  private fieldChanges(field: FormlyFieldConfigCache | undefined) {\n    if (!field) {\n      return () => {};\n    }\n\n    const propsObserver = observeDeep(field, ['props'], () => field.options.detectChanges(field));\n    const subscribes = [\n      () => {\n        propsObserver();\n      },\n    ];\n\n    for (const key of Object.keys(field._expressions || {})) {\n      const expressionObserver = observe<FormlyFieldConfigCache['_expressions']['key']>(\n        field,\n        ['_expressions', key],\n        ({ currentValue, previousValue }) => {\n          if (previousValue?.subscription) {\n            previousValue.subscription.unsubscribe();\n            previousValue.subscription = null;\n          }\n          if (isObservable(currentValue.value$)) {\n            currentValue.subscription = currentValue.value$.subscribe();\n          }\n        },\n      );\n      subscribes.push(() => {\n        if (field._expressions[key]?.subscription) {\n          field._expressions[key].subscription.unsubscribe();\n        }\n        expressionObserver.unsubscribe();\n      });\n    }\n\n    for (const path of [['focus'], ['template'], ['fieldGroupClassName'], ['validation', 'show']]) {\n      const fieldObserver = observe(\n        field,\n        path,\n        ({ firstChange }) => !firstChange && field.options.detectChanges(field),\n      );\n      subscribes.push(() => fieldObserver.unsubscribe());\n    }\n\n    if (field.formControl && !field.fieldGroup) {\n      const control = field.formControl;\n      let valueChanges = control.valueChanges.pipe(\n        map((value) => {\n          field.parsers?.map((parserFn) => (value = (parserFn as any)(value, field)));\n          if (!Object.is(value, field.formControl.value)) {\n            field.formControl.setValue(value);\n          }\n\n          return value;\n        }),\n        distinctUntilChanged((x, y) => {\n          if (x !== y || Array.isArray(x) || isObject(x)) {\n            return false;\n          }\n\n          return true;\n        }),\n      );\n\n      if (control.value !== getFieldValue(field)) {\n        valueChanges = valueChanges.pipe(startWith(control.value));\n      }\n\n      const { updateOn, debounce } = field.modelOptions;\n      if ((!updateOn || updateOn === 'change') && debounce?.default > 0) {\n        valueChanges = control.valueChanges.pipe(debounceTime(debounce.default));\n      }\n\n      const sub = valueChanges.subscribe((value) => {\n        // workaround for https://github.com/angular/angular/issues/13792\n        if (control._fields?.length > 1 && control instanceof FormControl) {\n          control.patchValue(value, { emitEvent: false, onlySelf: true });\n        }\n\n        if (hasKey(field)) {\n          assignFieldValue(field, value);\n        }\n        field.options.fieldChanges.next({ value, field, type: 'valueChanges' });\n      });\n\n      subscribes.push(() => sub.unsubscribe());\n    }\n\n    let templateFieldsSubs: (() => void)[] = [];\n    observe(field, ['_localFields'], ({ currentValue }) => {\n      templateFieldsSubs.forEach((unsubscribe) => unsubscribe());\n      templateFieldsSubs = (currentValue || []).map((f: FormlyFieldConfigCache) => this.fieldChanges(f));\n    });\n\n    return () => {\n      subscribes.forEach((unsubscribe) => unsubscribe());\n      templateFieldsSubs.forEach((unsubscribe) => unsubscribe());\n    };\n  }\n}\n\n@Component({\n  selector: 'formly-field',\n  template: '<ng-template #container></ng-template>',\n  styleUrls: ['./formly.field.scss'],\n  standalone: false,\n})\nexport class LegacyFormlyField extends FormlyField {}\n"]}

package/esm2022/lib/components/formly.form.mjs

@@ -0,0 +1,164 @@
+import { Component, ChangeDetectionStrategy, Input, EventEmitter, Output, ContentChildren, } from '@angular/core';
+import { FormlyFormBuilder } from '../services/formly.builder';
+import { clone, hasKey, isNoopNgZone, isSignalRequired, observeDeep } from '../utils';
+import { switchMap, filter, take } from 'rxjs/operators';
+import { clearControl } from '../extensions/field-form/utils';
+import { FormlyFieldTemplates, FormlyTemplate } from './formly.template';
+import { of } from 'rxjs';
+import { FormlyField } from './formly.field';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/formly.builder";
+import * as i2 from "../services/formly.config";
+import * as i3 from "./formly.template";
+import * as i4 from "./formly.field";
+/**
+ * The `<form-form>` component is the main container of the form,
+ * which takes care of managing the form state
+ * and delegates the rendering of each field to `<formly-field>` component.
+ */
+export class FormlyForm {
+    /** The form instance which allow to track model value and validation status. */
+    set form(form) {
+        this.field.form = form;
+    }
+    get form() {
+        return this.field.form;
+    }
+    /** The model to be represented by the form. */
+    set model(model) {
+        if (this.config.extras.immutable && this._modelChangeValue === model) {
+            return;
+        }
+        this.setField({ model });
+    }
+    get model() {
+        return this.field.model;
+    }
+    /** The field configurations for building the form. */
+    set fields(fieldGroup) {
+        this.setField({ fieldGroup });
+    }
+    get fields() {
+        return this.field.fieldGroup;
+    }
+    /** Options for the form. */
+    set options(options) {
+        this.setField({ options });
+    }
+    get options() {
+        return this.field.options;
+    }
+    set templates(templates) {
+        this.fieldTemplates.templates = templates;
+    }
+    constructor(builder, config, ngZone, fieldTemplates) {
+        this.builder = builder;
+        this.config = config;
+        this.ngZone = ngZone;
+        this.fieldTemplates = fieldTemplates;
+        /** Event that is emitted when the model value is changed */
+        this.modelChange = new EventEmitter();
+        this.field = { type: 'formly-group' };
+        this._modelChangeValue = {};
+        this.valueChangesUnsubscribe = () => { };
+    }
+    ngDoCheck() {
+        if (this.config.extras.checkExpressionOn === 'changeDetectionCheck') {
+            this.checkExpressionChange();
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes.fields && this.form) {
+            clearControl(this.form);
+        }
+        if (changes.fields || changes.form || (changes.model && this._modelChangeValue !== changes.model.currentValue)) {
+            this.valueChangesUnsubscribe();
+            this.builder.build(this.field);
+            this.valueChangesUnsubscribe = this.valueChanges();
+        }
+    }
+    ngOnDestroy() {
+        this.valueChangesUnsubscribe();
+    }
+    checkExpressionChange() {
+        this.field.options.checkExpressions?.(this.field);
+    }
+    valueChanges() {
+        this.valueChangesUnsubscribe();
+        let formEvents = null;
+        if (isSignalRequired()) {
+            let submitted = this.options?.parentForm?.submitted;
+            formEvents = this.form.events.subscribe(() => {
+                if (submitted !== this.options?.parentForm?.submitted) {
+                    this.options.detectChanges(this.field);
+                    submitted = this.options?.parentForm?.submitted;
+                }
+            });
+        }
+        const fieldChangesDetection = [
+            observeDeep(this.field.options, ['formState'], () => this.field.options.detectChanges(this.field)),
+        ];
+        const valueChanges = this.field.options.fieldChanges
+            .pipe(filter(({ field, type }) => hasKey(field) && type === 'valueChanges'), switchMap(() => (isNoopNgZone(this.ngZone) ? of(null) : this.ngZone.onStable.asObservable().pipe(take(1)))))
+            .subscribe(() => this.ngZone.runGuarded(() => {
+            // runGuarded is used to keep in sync the expression changes
+            // https://github.com/ngx-formly/ngx-formly/issues/2095
+            this.checkExpressionChange();
+            this.modelChange.emit((this._modelChangeValue = clone(this.model)));
+        }));
+        return () => {
+            fieldChangesDetection.forEach((fnc) => fnc());
+            formEvents?.unsubscribe();
+            valueChanges.unsubscribe();
+        };
+    }
+    setField(field) {
+        if (this.config.extras.immutable) {
+            this.field = { ...this.field, ...clone(field) };
+        }
+        else {
+            Object.keys(field).forEach((p) => (this.field[p] = field[p]));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyForm, deps: [{ token: i1.FormlyFormBuilder }, { token: i2.FormlyConfig }, { token: i0.NgZone }, { token: i3.FormlyFieldTemplates }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormlyForm, isStandalone: true, selector: "formly-form", inputs: { form: "form", model: "model", fields: "fields", options: "options" }, outputs: { modelChange: "modelChange" }, providers: [FormlyFormBuilder, FormlyFieldTemplates], queries: [{ propertyName: "templates", predicate: FormlyTemplate }], usesOnChanges: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: FormlyField, selector: "formly-field", inputs: ["field"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyForm, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-form',
+                    template: '<formly-field [field]="field"></formly-field>',
+                    providers: [FormlyFormBuilder, FormlyFieldTemplates],
+                    imports: [FormlyField],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.FormlyFormBuilder }, { type: i2.FormlyConfig }, { type: i0.NgZone }, { type: i3.FormlyFieldTemplates }], propDecorators: { form: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], fields: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], modelChange: [{
+                type: Output
+            }], templates: [{
+                type: ContentChildren,
+                args: [FormlyTemplate]
+            }] } });
+export class LegacyFormlyForm extends FormlyForm {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyForm, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LegacyFormlyForm, selector: "formly-form", providers: [FormlyFormBuilder, FormlyFieldTemplates], usesInheritance: true, ngImport: i0, template: '<formly-field [field]="field"></formly-field>', isInline: true, dependencies: [{ kind: "component", type: i4.LegacyFormlyField, selector: "formly-field" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LegacyFormlyForm, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-form',
+                    template: '<formly-field [field]="field"></formly-field>',
+                    providers: [FormlyFormBuilder, FormlyFieldTemplates],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.form.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/components/formly.form.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ChangeDetectionStrategy,\n  DoCheck,\n  OnChanges,\n  Input,\n  SimpleChanges,\n  EventEmitter,\n  Output,\n  OnDestroy,\n  NgZone,\n  ContentChildren,\n  QueryList,\n} from '@angular/core';\nimport { UntypedFormGroup, UntypedFormArray } from '@angular/forms';\nimport { FormlyFieldConfig, FormlyFormOptions, FormlyFieldConfigCache } from '../models';\nimport { FormlyFormBuilder } from '../services/formly.builder';\nimport { FormlyConfig } from '../services/formly.config';\nimport { clone, hasKey, isNoopNgZone, isSignalRequired, observeDeep } from '../utils';\nimport { switchMap, filter, take } from 'rxjs/operators';\nimport { clearControl } from '../extensions/field-form/utils';\nimport { FormlyFieldTemplates, FormlyTemplate } from './formly.template';\nimport { of, Subscription } from 'rxjs';\nimport { FormlyField } from './formly.field';\n\n/**\n * The `<form-form>` component is the main container of the form,\n * which takes care of managing the form state\n * and delegates the rendering of each field to `<formly-field>` component.\n */\n@Component({\n  selector: 'formly-form',\n  template: '<formly-field [field]=\"field\"></formly-field>',\n  providers: [FormlyFormBuilder, FormlyFieldTemplates],\n  imports: [FormlyField],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n})\nexport class FormlyForm implements DoCheck, OnChanges, OnDestroy {\n  /** The form instance which allow to track model value and validation status. */\n  @Input()\n  set form(form: UntypedFormGroup | UntypedFormArray) {\n    this.field.form = form;\n  }\n  get form(): UntypedFormGroup | UntypedFormArray {\n    return this.field.form;\n  }\n\n  /** The model to be represented by the form. */\n  @Input()\n  set model(model: any) {\n    if (this.config.extras.immutable && this._modelChangeValue === model) {\n      return;\n    }\n\n    this.setField({ model });\n  }\n  get model(): any {\n    return this.field.model;\n  }\n\n  /** The field configurations for building the form. */\n  @Input()\n  set fields(fieldGroup: FormlyFieldConfig[]) {\n    this.setField({ fieldGroup });\n  }\n  get fields(): FormlyFieldConfig[] {\n    return this.field.fieldGroup;\n  }\n\n  /** Options for the form. */\n  @Input()\n  set options(options: FormlyFormOptions) {\n    this.setField({ options });\n  }\n  get options(): FormlyFormOptions {\n    return this.field.options;\n  }\n\n  /** Event that is emitted when the model value is changed */\n  @Output() modelChange = new EventEmitter<any>();\n  @ContentChildren(FormlyTemplate) set templates(templates: QueryList<FormlyTemplate>) {\n    this.fieldTemplates.templates = templates;\n  }\n\n  field: FormlyFieldConfigCache = { type: 'formly-group' };\n  private _modelChangeValue: any = {};\n  private valueChangesUnsubscribe = () => {};\n\n  constructor(\n    private builder: FormlyFormBuilder,\n    private config: FormlyConfig,\n    private ngZone: NgZone,\n    private fieldTemplates: FormlyFieldTemplates,\n  ) {}\n\n  ngDoCheck() {\n    if (this.config.extras.checkExpressionOn === 'changeDetectionCheck') {\n      this.checkExpressionChange();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.fields && this.form) {\n      clearControl(this.form);\n    }\n\n    if (changes.fields || changes.form || (changes.model && this._modelChangeValue !== changes.model.currentValue)) {\n      this.valueChangesUnsubscribe();\n      this.builder.build(this.field);\n      this.valueChangesUnsubscribe = this.valueChanges();\n    }\n  }\n\n  ngOnDestroy() {\n    this.valueChangesUnsubscribe();\n  }\n\n  private checkExpressionChange() {\n    this.field.options.checkExpressions?.(this.field);\n  }\n\n  private valueChanges() {\n    this.valueChangesUnsubscribe();\n\n    let formEvents: Subscription | null = null;\n    if (isSignalRequired()) {\n      let submitted = this.options?.parentForm?.submitted;\n      formEvents = (this.form as any).events.subscribe(() => {\n        if (submitted !== this.options?.parentForm?.submitted) {\n          this.options.detectChanges(this.field);\n          submitted = this.options?.parentForm?.submitted;\n        }\n      });\n    }\n\n    const fieldChangesDetection: any[] = [\n      observeDeep(this.field.options, ['formState'], () => this.field.options.detectChanges(this.field)),\n    ];\n    const valueChanges = this.field.options.fieldChanges\n      .pipe(\n        filter(({ field, type }) => hasKey(field) && type === 'valueChanges'),\n        switchMap(() => (isNoopNgZone(this.ngZone) ? of(null) : this.ngZone.onStable.asObservable().pipe(take(1)))),\n      )\n      .subscribe(() =>\n        this.ngZone.runGuarded(() => {\n          // runGuarded is used to keep in sync the expression changes\n          // https://github.com/ngx-formly/ngx-formly/issues/2095\n          this.checkExpressionChange();\n          this.modelChange.emit((this._modelChangeValue = clone(this.model)));\n        }),\n      );\n\n    return () => {\n      fieldChangesDetection.forEach((fnc) => fnc());\n      formEvents?.unsubscribe();\n      valueChanges.unsubscribe();\n    };\n  }\n\n  private setField(field: FormlyFieldConfigCache) {\n    if (this.config.extras.immutable) {\n      this.field = { ...this.field, ...clone(field) };\n    } else {\n      Object.keys(field).forEach((p) => ((this.field as any)[p] = (field as any)[p]));\n    }\n  }\n}\n\n@Component({\n  selector: 'formly-form',\n  template: '<formly-field [field]=\"field\"></formly-field>',\n  providers: [FormlyFormBuilder, FormlyFieldTemplates],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: false,\n})\nexport class LegacyFormlyForm extends FormlyForm {}\n"]}

package/{esm2020 → esm2022}/lib/components/formly.template.mjs

@@ -7,22 +7,22 @@ export class FormlyTemplate {
     ngOnChanges() {
         this.name = this.name || 'formly-group';
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplate, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FormlyTemplate, selector: "[formlyTemplate]", inputs: { name: ["formlyTemplate", "name"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-FormlyTemplate.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyTemplate, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
-FormlyTemplate.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.12", type: FormlyTemplate, selector: "[formlyTemplate]", inputs: { name: ["formlyTemplate", "name"] }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyTemplate, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyTemplate, decorators: [{
             type: Directive,
             args: [{ selector: '[formlyTemplate]' }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { name: [{
+        }], ctorParameters: () => [{ type: i0.TemplateRef }], propDecorators: { name: [{
                 type: Input,
                 args: ['formlyTemplate']
             }] } });
 // workarround for https://github.com/angular/angular/issues/43227#issuecomment-904173738
 export class FormlyFieldTemplates {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates }); }
 }
-FormlyFieldTemplates.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyFieldTemplates, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FormlyFieldTemplates.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyFieldTemplates });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyFieldTemplates, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyFieldTemplates, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWx5LnRlbXBsYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NvcmUvc3JjL2xpYi9jb21wb25lbnRzL2Zvcm1seS50ZW1wbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQXFDLE1BQU0sZUFBZSxDQUFDOztBQUdoRyxNQUFNLE9BQU8sY0FBYztJQUd6QixZQUFtQixHQUFxQjtRQUFyQixRQUFHLEdBQUgsR0FBRyxDQUFrQjtJQUFHLENBQUM7SUFFNUMsV0FBVztRQUNULElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksSUFBSSxjQUFjLENBQUM7SUFDMUMsQ0FBQzs7NEdBUFUsY0FBYztnR0FBZCxjQUFjOzRGQUFkLGNBQWM7a0JBRDFCLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUsa0JBQWtCLEVBQUU7a0dBRWhCLElBQUk7c0JBQTVCLEtBQUs7dUJBQUMsZ0JBQWdCOztBQVN6Qix5RkFBeUY7QUFFekYsTUFBTSxPQUFPLG9CQUFvQjs7a0hBQXBCLG9CQUFvQjtzSEFBcEIsb0JBQW9COzRGQUFwQixvQkFBb0I7a0JBRGhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGFibGUsIElucHV0LCBPbkNoYW5nZXMsIFF1ZXJ5TGlzdCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW2Zvcm1seVRlbXBsYXRlXScgfSlcbmV4cG9ydCBjbGFzcyBGb3JtbHlUZW1wbGF0ZSBpbXBsZW1lbnRzIE9uQ2hhbmdlcyB7XG4gIEBJbnB1dCgnZm9ybWx5VGVtcGxhdGUnKSBuYW1lOiBzdHJpbmc7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHJlZjogVGVtcGxhdGVSZWY8YW55Pikge31cblxuICBuZ09uQ2hhbmdlcygpIHtcbiAgICB0aGlzLm5hbWUgPSB0aGlzLm5hbWUgfHwgJ2Zvcm1seS1ncm91cCc7XG4gIH1cbn1cblxuLy8gd29ya2Fycm91bmQgZm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2FuZ3VsYXIvaXNzdWVzLzQzMjI3I2lzc3VlY29tbWVudC05MDQxNzM3MzhcbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGb3JtbHlGaWVsZFRlbXBsYXRlcyB7XG4gIHRlbXBsYXRlcyE6IFF1ZXJ5TGlzdDxGb3JtbHlUZW1wbGF0ZT47XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWx5LnRlbXBsYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NvcmUvc3JjL2xpYi9jb21wb25lbnRzL2Zvcm1seS50ZW1wbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQXFDLE1BQU0sZUFBZSxDQUFDOztBQUdoRyxNQUFNLE9BQU8sY0FBYztJQUd6QixZQUFtQixHQUFxQjtRQUFyQixRQUFHLEdBQUgsR0FBRyxDQUFrQjtJQUFHLENBQUM7SUFFNUMsV0FBVztRQUNULElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksSUFBSSxjQUFjLENBQUM7SUFDMUMsQ0FBQzsrR0FQVSxjQUFjO21HQUFkLGNBQWM7OzRGQUFkLGNBQWM7a0JBRDFCLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUsa0JBQWtCLEVBQUU7Z0ZBRWhCLElBQUk7c0JBQTVCLEtBQUs7dUJBQUMsZ0JBQWdCOztBQVN6Qix5RkFBeUY7QUFFekYsTUFBTSxPQUFPLG9CQUFvQjsrR0FBcEIsb0JBQW9CO21IQUFwQixvQkFBb0I7OzRGQUFwQixvQkFBb0I7a0JBRGhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGFibGUsIElucHV0LCBPbkNoYW5nZXMsIFF1ZXJ5TGlzdCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW2Zvcm1seVRlbXBsYXRlXScgfSlcbmV4cG9ydCBjbGFzcyBGb3JtbHlUZW1wbGF0ZSBpbXBsZW1lbnRzIE9uQ2hhbmdlcyB7XG4gIEBJbnB1dCgnZm9ybWx5VGVtcGxhdGUnKSBuYW1lOiBzdHJpbmc7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHJlZjogVGVtcGxhdGVSZWY8YW55Pikge31cblxuICBuZ09uQ2hhbmdlcygpIHtcbiAgICB0aGlzLm5hbWUgPSB0aGlzLm5hbWUgfHwgJ2Zvcm1seS1ncm91cCc7XG4gIH1cbn1cblxuLy8gd29ya2Fycm91bmQgZm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2FuZ3VsYXIvaXNzdWVzLzQzMjI3I2lzc3VlY29tbWVudC05MDQxNzM3MzhcbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGb3JtbHlGaWVsZFRlbXBsYXRlcyB7XG4gIHRlbXBsYXRlcyE6IFF1ZXJ5TGlzdDxGb3JtbHlUZW1wbGF0ZT47XG59XG4iXX0=

package/esm2022/lib/core.config.mjs

@@ -0,0 +1,36 @@
+import { InjectionToken } from '@angular/core';
+import { FieldExpressionExtension } from './extensions';
+import { CoreExtension } from './extensions/core/core';
+import { FieldFormExtension } from './extensions/field-form/field-form';
+import { FieldValidationExtension } from './extensions/field-validation/field-validation';
+import { FormlyTemplateType } from './templates/field-template.type';
+import { FormlyGroup } from './templates/formly.group';
+import { FormlyConfig } from './services/formly.config';
+/**
+ * An InjectionToken for registering additional formly config options (types, wrappers ...).
+ */
+export const FORMLY_CONFIG = new InjectionToken('FORMLY_CONFIG');
+export function withDefaultConfig(config) {
+    return {
+        types: [
+            { name: 'formly-group', component: FormlyGroup },
+            { name: 'formly-template', component: FormlyTemplateType },
+        ],
+        extensions: [
+            { name: 'core', extension: new CoreExtension(config), priority: -250 },
+            { name: 'field-validation', extension: new FieldValidationExtension(config), priority: -200 },
+            { name: 'field-form', extension: new FieldFormExtension(), priority: -150 },
+            { name: 'field-expression', extension: new FieldExpressionExtension(), priority: -100 },
+        ],
+    };
+}
+export const provideFormlyCore = (configs = []) => {
+    return [
+        { provide: FORMLY_CONFIG, multi: true, useFactory: withDefaultConfig, deps: [FormlyConfig] },
+        provideFormlyConfig(configs),
+    ];
+};
+export const provideFormlyConfig = (configs = []) => {
+    return [{ provide: FORMLY_CONFIG, multi: true, useValue: configs }];
+};
+//# sourceMappingURL=data:application/json;base64,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