@ngx-formly/core 6.0.2 → 6.0.3

package/fesm2020/ngx-formly-core.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { Type, TemplateRef, ComponentRef, ChangeDetectorRef, InjectionToken, Injectable, Optional, Directive, Input, ViewContainerRef, Component, ViewChild, EventEmitter, ChangeDetectionStrategy, Output, ContentChildren, Inject, NgModule } from '@angular/core';
 import * as i2 from '@angular/forms';
 import { AbstractControl, FormGroup, FormArray, FormControl, Validators } from '@angular/forms';
-import { isObservable, merge, of, Observable, Subject } from 'rxjs';
+import { isObservable, merge, of, Observable, tap, Subject } from 'rxjs';
 import { distinctUntilChanged, startWith, debounceTime, filter, switchMap, take, map } from 'rxjs/operators';
 import * as i2$1 from '@angular/common';
 import { DOCUMENT, CommonModule } from '@angular/common';
@@ -889,6 +889,23 @@ class FormlyField {
             observeDeep(field, ['props'], () => field.options.detectChanges(field)),
             observeDeep(field.options, ['formState'], () => field.options.detectChanges(field)),
         ];
+        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 [['template'], ['fieldGroupClassName'], ['validation', 'show']]) {
             const fieldObserver = observe(field, path, ({ firstChange }) => !firstChange && field.options.detectChanges(field));
             subscribes.push(() => fieldObserver.unsubscribe());
@@ -1408,7 +1425,8 @@ class FieldArrayType extends FieldType {
         markAsDirty && this.formControl.markAsDirty();
     }
     _build() {
-        this.options.build(this.field);
+        const fields = this.field.formControl._fields ?? [this.field];
+        fields.forEach((f) => this.options.build(f));
         this.options.fieldChanges.next({
             field: this.field,
             value: getFieldValue(this.field),
@@ -1510,22 +1528,11 @@ class FieldExpressionExtension {
                 field._expressions[key] = this.parseExpressions(field, key, expr);
             }
             else if (expr instanceof Observable) {
-                const subscribe = () => expr.subscribe((v) => {
-                    this.evalExpr(field, key, v);
-                });
-                let subscription = null;
-                const onInit = field.hooks.onInit;
-                field.hooks.onInit = () => {
-                    if (subscription === null) {
-                        subscription = subscribe();
-                    }
-                    return onInit?.(field);
-                };
-                const onDestroy = field.hooks.onDestroy;
-                field.hooks.onDestroy = () => {
-                    onDestroy?.(field);
-                    subscription.unsubscribe();
-                    subscription = null;
+                field._expressions[key] = {
+                    value$: expr.pipe(tap((v) => {
+                        this.evalExpr(field, key, v);
+                        field.options.detectChanges(field);
+                    })),
                 };
             }
         };
@@ -1619,7 +1626,7 @@ class FieldExpressionExtension {
         let fieldChanged = false;
         if (field._expressions) {
             for (const key of Object.keys(field._expressions)) {
-                field._expressions[key].callback(ignoreCache) && (fieldChanged = true);
+                field._expressions[key].callback?.(ignoreCache) && (fieldChanged = true);
             }
         }
         field.fieldGroup?.forEach((f) => this.checkExpressions(f, ignoreCache) && (fieldChanged = true));