@ngx-formly/core 5.10.29 → 5.10.33

package/bundles/ngx-formly-core.umd.js

@@ -102,6 +102,20 @@
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
      */
+    /**
+     * @param {?} form
+     * @param {?} callback
+     * @return {?}
+     */
+    function disableTreeValidityCall(form, callback) {
+        /** @type {?} */
+        var _updateTreeValidity = form._updateTreeValidity.bind(form);
+        form._updateTreeValidity = ( /**
+         * @return {?}
+         */function () { });
+        callback();
+        form._updateTreeValidity = _updateTreeValidity;
+    }
     /**
      * @param {?} formId
      * @param {?} field
@@ -113,8 +127,12 @@
             return field.id;
         /** @type {?} */
         var type = field.type;
-        if (!type && field.template)
+        if (!type && field.template) {
             type = 'template';
+        }
+        if (isFunction(type)) {
+            type = (( /** @type {?} */(type))).prototype.constructor.name;
+        }
         return [formId, type, field.key, index].join('_');
     }
     /**
@@ -421,27 +439,6 @@
          * @return {?}
          */function () { return fns.splice(fns.indexOf(setFn), 1); });
     }
-    /**
-     * @param {?} form
-     * @param {?} action
-     * @return {?}
-     */
-    function reduceFormUpdateValidityCalls(form, action) {
-        /** @type {?} */
-        var updateValidity = form._updateTreeValidity.bind(form);
-        /** @type {?} */
-        var updateValidityArgs = { called: false, emitEvent: false };
-        form._updateTreeValidity = ( /**
-         * @param {?=} __0
-         * @return {?}
-         */function (_a) {
-            var emitEvent = (_a === void 0 ? { emitEvent: true } : _a).emitEvent;
-            return updateValidityArgs = { called: true, emitEvent: emitEvent || updateValidityArgs.emitEvent };
-        });
-        action();
-        updateValidityArgs.called && updateValidity({ emitEvent: updateValidityArgs.emitEvent });
-        form._updateTreeValidity = updateValidity;
-    }
 
     /**
      * @fileoverview added by tsickle
@@ -825,7 +822,7 @@
                 }
                 /** @type {?} */
                 var field = { fieldGroup: fieldGroup, model: model, formControl: formControl, options: this._setOptions(options) };
-                reduceFormUpdateValidityCalls(formControl, ( /**
+                disableTreeValidityCall(formControl, ( /**
                  * @return {?}
                  */function () { return _this._buildForm(field); }));
                 field.options._checkField(field, true);
@@ -1101,15 +1098,24 @@
     }
     /**
      * @param {?} c
+     * @param {?=} onlySelf
      * @return {?}
      */
-    function updateValidity(c) {
+    function updateValidity(c, onlySelf) {
+        if (onlySelf === void 0) {
+            onlySelf = false;
+        }
         /** @type {?} */
         var status = c.status;
-        c.updateValueAndValidity({ emitEvent: false });
+        /** @type {?} */
+        var value = c.value;
+        c.updateValueAndValidity({ emitEvent: false, onlySelf: onlySelf });
         if (status !== c.status) {
             (( /** @type {?} */(c.statusChanges))).emit(c.status);
         }
+        if (value !== c.value) {
+            (( /** @type {?} */(c.valueChanges))).emit(c.value);
+        }
     }
     /**
      * @param {?} form
@@ -1909,16 +1915,11 @@
      */
     var FormlyAttributes = /** @class */ (function () {
         function FormlyAttributes(renderer, elementRef, _document) {
+            var _this = this;
             this.renderer = renderer;
             this.elementRef = elementRef;
             this.uiAttributesCache = {};
-            this.uiAttributes = __spread(FORMLY_VALIDATORS, [
-                'tabindex',
-                'placeholder',
-                'readonly',
-                'disabled',
-                'step',
-            ]);
+            this.uiAttributes = null;
             /**
              * HostBinding doesn't register listeners conditionally which may produce some perf issues.
              *
@@ -1926,12 +1927,23 @@
              */
             this.uiEvents = {
                 listeners: [],
-                events: [
-                    'click',
-                    'keyup',
-                    'keydown',
-                    'keypress',
-                ],
+                events: ['click', 'keyup', 'keydown', 'keypress', 'focus', 'blur', 'change'],
+                callback: ( /**
+                 * @param {?} eventName
+                 * @param {?} $event
+                 * @return {?}
+                 */function (eventName, $event) {
+                    switch (eventName) {
+                        case 'focus':
+                            return _this.onFocus($event);
+                        case 'blur':
+                            return _this.onBlur($event);
+                        case 'change':
+                            return _this.onChange($event);
+                        default:
+                            return _this.to[eventName](_this.field, $event);
+                    }
+                }),
             };
             this.document = _document;
         }
@@ -1970,11 +1982,11 @@
                      * @param {?} eventName
                      * @return {?}
                      */function (eventName) {
-                        if (_this.to && _this.to[eventName]) {
+                        if ((_this.to && _this.to[eventName]) || ['focus', 'blur', 'change'].indexOf(eventName) !== -1) {
                             _this.uiEvents.listeners.push(_this.renderer.listen(_this.elementRef.nativeElement, eventName, ( /**
                              * @param {?} e
                              * @return {?}
-                             */function (e) { return _this.to[eventName](_this.field, e); })));
+                             */function (e) { return _this.uiEvents.callback(eventName, e); })));
                         }
                     }));
                     if (this.to && this.to.attributes) {
@@ -2046,6 +2058,14 @@
          */
             function () {
                 var _this = this;
+                if (!this.uiAttributes) {
+                    /** @type {?} */
+                    var element_1 = ( /** @type {?} */(this.elementRef.nativeElement));
+                    this.uiAttributes = __spread(FORMLY_VALIDATORS, ['tabindex', 'placeholder', 'readonly', 'disabled', 'step']).filter(( /**
+                     * @param {?} attr
+                     * @return {?}
+                     */function (attr) { return !element_1.hasAttribute || !element_1.hasAttribute(attr); }));
+                }
                 this.uiAttributes.forEach(( /**
                  * @param {?} attr
                  * @return {?}
@@ -2137,6 +2157,24 @@
                     this.to.blur(this.field, $event);
                 }
             };
+        // handle custom `change` event, for regular ones rely on DOM listener
+        // handle custom `change` event, for regular ones rely on DOM listener
+        /**
+         * @param {?} $event
+         * @return {?}
+         */
+        FormlyAttributes.prototype.onHostChange =
+            // handle custom `change` event, for regular ones rely on DOM listener
+            /**
+             * @param {?} $event
+             * @return {?}
+             */
+            function ($event) {
+                if ($event instanceof Event) {
+                    return;
+                }
+                this.onChange($event);
+            };
         /**
          * @param {?} $event
          * @return {?}
@@ -2223,9 +2261,7 @@
             { type: i0.Directive, args: [{
                         selector: '[formlyAttributes]',
                         host: {
-                            '(focus)': 'onFocus($event)',
-                            '(blur)': 'onBlur($event)',
-                            '(change)': 'onChange($event)',
+                            '(change)': 'onHostChange($event)',
                         },
                     },] }
         ];
@@ -2719,9 +2755,7 @@
                  */function (f, ignoreCache) {
                     if (!checkLocked) {
                         checkLocked = true;
-                        reduceFormUpdateValidityCalls(f.formControl, ( /**
-                         * @return {?}
-                         */function () { return _this.checkField(f, ignoreCache); }));
+                        _this.checkField(f, ignoreCache);
                         checkLocked = false;
                     }
                 });
@@ -3499,22 +3533,7 @@
                 if (field.parent) {
                     return;
                 }
-                /** @type {?} */
-                var fieldsToUpdate = this.setValidators(field);
-                if (fieldsToUpdate.length === 0) {
-                    return;
-                }
-                if (fieldsToUpdate.length === 1) {
-                    /** @type {?} */
-                    var control = fieldsToUpdate[0].formControl;
-                    while (control) {
-                        (( /** @type {?} */(control)))._updateTreeValidity({ onlySelf: true });
-                        control = control.parent;
-                    }
-                }
-                else {
-                    (( /** @type {?} */(field.formControl)))._updateTreeValidity();
-                }
+                this.setValidators(field);
             };
         /**
          * @private
@@ -3555,39 +3574,40 @@
         /**
          * @private
          * @param {?} field
+         * @param {?=} disabled
          * @return {?}
          */
         FieldFormExtension.prototype.setValidators = /**
          * @private
          * @param {?} field
+         * @param {?=} disabled
          * @return {?}
          */
-            function (field) {
+            function (field, disabled) {
                 var _this = this;
+                if (disabled === void 0) {
+                    disabled = false;
+                }
                 /** @type {?} */
-                var updateValidity$$1 = false;
+                var markForCheck = false;
+                if (disabled === false && field.key && field.templateOptions && field.templateOptions.disabled) {
+                    disabled = true;
+                }
+                (field.fieldGroup || []).forEach(( /**
+                 * @param {?} f
+                 * @return {?}
+                 */function (f) { return _this.setValidators(f, disabled) && (markForCheck = true); }));
                 if (field.key || !field.parent || (!field.key && !field.fieldGroup)) {
                     var c_1 = field.formControl;
-                    /** @type {?} */
-                    var disabled = field.templateOptions ? field.templateOptions.disabled : false;
-                    if (field.key && c_1) {
+                    field.templateOptions = field.templateOptions || {};
+                    if (field.key && c_1 && c_1 instanceof forms.FormControl) {
                         if (disabled && c_1.enabled) {
                             c_1.disable({ emitEvent: false, onlySelf: true });
-                            if (!c_1.parent) {
-                                updateValidity(c_1);
-                            }
-                            else {
-                                updateValidity$$1 = true;
-                            }
+                            markForCheck = true;
                         }
                         if (!disabled && c_1.disabled) {
                             c_1.enable({ emitEvent: false, onlySelf: true });
-                            if (!c_1.parent) {
-                                updateValidity(c_1);
-                            }
-                            else {
-                                updateValidity$$1 = true;
-                            }
+                            markForCheck = true;
                         }
                     }
                     if (c_1 && (null === c_1.validator || null === c_1.asyncValidator)) {
@@ -3605,27 +3625,13 @@
                             var v = forms.Validators.composeAsync(_this.mergeValidators(field, '_asyncValidators'));
                             return v ? v(c_1) : rxjs.of(null);
                         }));
-                        if (!c_1.parent) {
-                            updateValidity(c_1);
-                        }
-                        else {
-                            updateValidity$$1 = true;
-                        }
+                        markForCheck = true;
                     }
-                }
-                /** @type {?} */
-                var fieldsToUpdate = updateValidity$$1 ? [field] : [];
-                (field.fieldGroup || []).forEach(( /**
-                 * @param {?} f
-                 * @return {?}
-                 */function (f) {
-                    /** @type {?} */
-                    var childrenToUpdate = _this.setValidators(f);
-                    if (!updateValidity$$1) {
-                        fieldsToUpdate.push.apply(fieldsToUpdate, __spread(childrenToUpdate));
+                    if (markForCheck) {
+                        updateValidity(c_1, true);
                     }
-                }));
-                return fieldsToUpdate;
+                }
+                return markForCheck;
             };
         /**
          * @private