@sumaris-net/ngx-components 1.2.7 → 1.2.14

package/esm2020/src/app/shared/forms.mjs

@@ -0,0 +1,391 @@
+import { UntypedFormArray, UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { isMoment } from 'moment';
+import { isNotEmptyArray, nullIfUndefined } from './functions';
+import { toDateISOString } from './dates';
+import { waitFor } from './observables';
+/**
+ * Fill a form using a source entity
+ *
+ * @param target
+ * @param entity
+ * @param opts
+ */
+export function copyEntity2Form(entity, target, opts) {
+    const json = getFormValueFromEntity(entity, target);
+    target.patchValue(json, opts);
+}
+export function getFormValueFromEntity(entity, form) {
+    return adaptValueToControl(entity, form);
+}
+/**
+ * Transform an entity into a simple object, compatible with the given form
+ *
+ * @param source an entity (or subentity)
+ * @param control
+ * @param path
+ */
+export function adaptValueToControl(source, control, path) {
+    const pathPrefix = path ? path + '.' : '';
+    // Form group
+    if (control instanceof UntypedFormGroup) {
+        const result = {};
+        // eslint-disable-next-line guard-for-in
+        for (const key in control.controls) {
+            result[key] = adaptValueToControl(source && source[key], control.controls[key], pathPrefix + key);
+        }
+        return result;
+    }
+    // Array
+    if (control instanceof UntypedFormArray) {
+        // Split, if many values in a string
+        if (typeof source === 'string') {
+            source = source.split('|');
+        }
+        // Skip if value is not an array
+        if (!Array.isArray(source) || control.length === 0) {
+            if (isNotEmptyArray(source))
+                console.warn(`WARN: please resize the FormArray '${path}' to the same length of the input array`);
+            return [];
+        }
+        // Use the first form group, as model
+        const firstItemControl = control.at(0);
+        let result = source.map((item, index) => adaptValueToControl(item, firstItemControl, pathPrefix + '#' + index));
+        // Truncate if too many values
+        if (result.length > control.length) {
+            if (firstItemControl instanceof UntypedFormControl) {
+                for (let i = control.length; i < result.length; i++) {
+                    control.push(new UntypedFormControl(null, firstItemControl.validator));
+                }
+            }
+            else {
+                console.warn(`WARN: please resize the FormArray '${path || ''}' to the same length of the input array`);
+                result = result.slice(0, control.length);
+            }
+        }
+        // Add values if not enought
+        else if (result.length < control.length) {
+            //console.warn(`WARN: Adding null value to array values`);
+            for (let i = result.length; i < control.length; i++) {
+                result.push(null);
+            }
+        }
+        return result;
+    }
+    // Form control
+    if (control instanceof UntypedFormControl) {
+        // Date
+        if (isMoment(source)) {
+            return toDateISOString(source);
+        }
+        // Any other control: replace undefined by null value
+        // because Undefined is not authorized as control value
+        else {
+            return nullIfUndefined(source);
+        }
+    }
+}
+export function logFormErrors(control, logPrefix, path) {
+    if (!control || control.valid)
+        return;
+    logPrefix = logPrefix || '';
+    // Form group
+    if (control instanceof UntypedFormGroup) {
+        if (!path)
+            console.warn(`${logPrefix} Form errors:`);
+        if (control.errors) {
+            Object.keys(control.errors).forEach(error => console.warn(`${logPrefix} -> ${path || ''} (${error})`));
+        }
+        if (control.controls) {
+            Object.keys(control.controls).forEach(child => logFormErrors(control.controls[child], logPrefix, (path ? `${path}.${child}` : child)) // Recursive call
+            );
+        }
+    }
+    // Form array
+    else if (control instanceof UntypedFormArray) {
+        if (control.errors) {
+            Object.keys(control.errors).forEach(error => console.warn(`${logPrefix} -> ${path || ''} (${error})`));
+        }
+        control.controls.forEach((child, index) => {
+            logFormErrors(child, logPrefix, (path ? `${path}.${index}` : `${index}`)); // Recursive call
+        });
+    }
+    // Other control's errors
+    else if (control.errors) {
+        Object.keys(control.errors).forEach(error => console.warn(`${logPrefix} -> ${path || ''} (${error})`));
+    }
+}
+export function getFormErrors(control, opts) {
+    if (!control || control.valid)
+        return undefined;
+    opts = opts || {};
+    opts.result = opts.result || {};
+    // Form group
+    if (control instanceof UntypedFormGroup) {
+        // Copy errors
+        if (control.errors) {
+            if (opts.controlName) {
+                opts.result[opts.controlName] = {
+                    ...control.errors
+                };
+            }
+            else {
+                opts.result = {
+                    ...opts.result,
+                    ...control.errors
+                };
+            }
+        }
+        if (!opts || opts.recursive !== false) {
+            // Loop on children controls
+            for (const key in control.controls) {
+                const child = control.controls[key];
+                if (child && child.enabled) {
+                    getFormErrors(child, {
+                        ...opts,
+                        controlName: opts.controlName ? [opts.controlName, key].join('.') : key,
+                        result: opts.result // Make sure to keep the same result object
+                    });
+                }
+            }
+        }
+    }
+    // Form array
+    else if (control instanceof UntypedFormArray) {
+        control.controls.forEach((child, index) => {
+            getFormErrors(child, {
+                ...opts,
+                controlName: (opts.controlName || '') + '.' + index,
+                result: opts.result // Make sure to keep the same result object
+            });
+        });
+    }
+    // Other type of control (e.g simple control)
+    else if (control.errors) {
+        if (opts.controlName) {
+            opts.result[opts.controlName] = {
+                ...control.errors
+            };
+        }
+        else {
+            opts.result = {
+                ...opts.result,
+                ...control.errors
+            };
+        }
+    }
+    return opts.result;
+}
+export function getControlFromPath(form, path) {
+    const i = path.indexOf('.');
+    if (i === -1) {
+        return form.controls[path];
+    }
+    const key = path.substring(0, i);
+    if (form.controls[key] instanceof UntypedFormGroup) {
+        return getControlFromPath(form.controls[key], path.substring(i + 1));
+    }
+    throw new Error(`Invalid form path: '${key}' should be a form group.`);
+}
+export function disableControls(form, paths, opts) {
+    (paths || []).forEach(path => {
+        const control = getControlFromPath(form, path);
+        if (control)
+            control.disable(opts);
+    });
+}
+export function addValueInArray(arrayControl, createControl, equals, isEmpty, value, options) {
+    const disabled = arrayControl.disabled;
+    let hasChanged = false;
+    let index = -1;
+    // Search if value already exists
+    if (!isEmpty(value)) {
+        index = (arrayControl.value || []).findIndex(v => equals(value, v));
+    }
+    // If value not exists, but last value is empty: use it
+    if (index === -1 && arrayControl.length && isEmpty(arrayControl.at(arrayControl.length - 1).value)) {
+        index = arrayControl.length - 1;
+    }
+    // Replace the existing value
+    if (index !== -1) {
+        if (!isEmpty(value)) {
+            arrayControl.at(index).patchValue(value, options);
+            hasChanged = true;
+        }
+    }
+    else {
+        const control = createControl(value);
+        // Apply parent disabled state, before to push it into the array
+        // This is need to avoid parent form to be enabled
+        if (disabled && control.enabled)
+            control.disable({ emitEvent: false });
+        else if (!disabled && control.disabled)
+            control.enable({ emitEvent: false });
+        arrayControl.push(control, options);
+        hasChanged = true;
+    }
+    if (hasChanged) {
+        if (!options || options.emitEvent !== false) {
+            // Mark array control dirty
+            if (!isEmpty(value)) {
+                arrayControl.markAsDirty();
+            }
+        }
+    }
+    return hasChanged;
+}
+/**
+ * Set an array using given default values. Each default value will be pass to the 'createControl()' function
+ * @param arrayControl
+ * @param createControl
+ * @param values
+ */
+export function initArrayControlsFromValues(arrayControl, createControl, defaultValues, options) {
+    if (arrayControl.length === 0 && (!defaultValues || defaultValues.length === 0))
+        return false; // No changes need
+    const disabled = arrayControl.disabled;
+    while (arrayControl.length > 0) {
+        arrayControl.removeAt(arrayControl.length - 1, options);
+    }
+    (defaultValues || []).forEach(value => {
+        const control = createControl(value);
+        // Apply parent disabled state, before to push it into the array
+        // This is need to avoid parent form to be enabled
+        if (disabled && control.enabled)
+            control.disable({ emitEvent: false });
+        else if (!disabled && control.disabled)
+            control.enable({ emitEvent: false });
+        arrayControl.push(control, options);
+    });
+    return true; // Has some changes
+}
+export function resizeArray(arrayControl, createControl, length, options) {
+    if (arrayControl.length === length)
+        return false; // No changes need
+    const disabled = arrayControl.disabled;
+    // Reduce size
+    while (arrayControl.length > length) {
+        arrayControl.removeAt(arrayControl.length - 1, options);
+    }
+    // Increase size
+    while (arrayControl.length < length) {
+        const control = createControl();
+        // Apply parent disabled state, before to push it into the array
+        // This is need to avoid parent form to be enabled, after calling resizeArray()
+        if (disabled && control.enabled)
+            control.disable({ emitEvent: false });
+        else if (!disabled && control.disabled)
+            control.enable({ emitEvent: false });
+        arrayControl.push(control, options);
+    }
+    return true; // Has some changes
+}
+export function removeValueInArray(arrayControl, isEmpty, index) {
+    arrayControl.removeAt(index);
+    arrayControl.markAsDirty();
+    return true;
+}
+export function clearValueInArray(arrayControl, isEmpty, index) {
+    const control = arrayControl.at(index);
+    if (isEmpty(control.value))
+        return false; // skip (not need to clear)
+    if (control instanceof UntypedFormGroup) {
+        copyEntity2Form({}, control);
+    }
+    else if (control instanceof UntypedFormArray) {
+        control.setValue([]);
+    }
+    else {
+        control.setValue(null);
+    }
+    arrayControl.markAsDirty();
+    return true;
+}
+export function markAllAsTouched(control, opts) {
+    if (!control)
+        return;
+    if (control instanceof UntypedFormGroup) {
+        markFormGroupAsTouched(control, { ...opts, onlySelf: true }); // recursive call
+    }
+    else if (control instanceof UntypedFormArray) {
+        control.markAsTouched({ onlySelf: true });
+        (control.controls || []).forEach(c => markControlAsTouched(c, { ...opts, onlySelf: true })); // recursive call
+    }
+    else {
+        control.markAsTouched({ onlySelf: true });
+        control.updateValueAndValidity({ ...opts, onlySelf: true });
+    }
+}
+export function markFormGroupAsTouched(form, opts) {
+    if (!form)
+        return;
+    form.markAsTouched(opts);
+    Object.keys(form.controls)
+        .map(key => form.controls[key])
+        .filter(control => control.enabled)
+        .forEach(control => markControlAsTouched(control, opts));
+    form.updateValueAndValidity({ ...opts, onlySelf: true });
+}
+export function markControlAsTouched(control, opts) {
+    if (!control)
+        return;
+    if (control instanceof UntypedFormGroup) {
+        markAllAsTouched(control, { ...opts, onlySelf: true }); // recursive call
+    }
+    else if (control instanceof UntypedFormArray) {
+        (control.controls || []).forEach(c => markControlAsTouched(c, { ...opts, onlySelf: true })); // recursive call
+    }
+    else {
+        control.markAsTouched({ onlySelf: true });
+        control.updateValueAndValidity({ ...opts, onlySelf: true });
+    }
+}
+export function updateValueAndValidity(form, opts) {
+    if (!form)
+        return;
+    form.updateValueAndValidity(opts);
+    Object.keys(form.controls)
+        .map(key => form.controls[key])
+        .filter(control => control.enabled)
+        .forEach(control => {
+        if (control instanceof UntypedFormGroup) {
+            updateValueAndValidity(control, { ...opts, onlySelf: true }); // recursive call
+        }
+        else {
+            control.updateValueAndValidity({ ...opts, onlySelf: true });
+        }
+    });
+}
+export function markAsUntouched(form, opts) {
+    if (!form)
+        return;
+    form.markAsUntouched(opts);
+    Object.getOwnPropertyNames(form.controls)
+        .forEach(key => {
+        const control = form.get(key);
+        if (control instanceof UntypedFormGroup) {
+            markAsUntouched(control, { onlySelf: true }); // recursive call
+        }
+        else {
+            control.markAsUntouched({ onlySelf: true });
+            control.setErrors(null);
+        }
+    });
+}
+/**
+ * Wait end of async validation (not pending). This need to implement {pending: boolean}
+ * return false
+ */
+export function waitWhilePending(form, opts) {
+    const predicate = () => form.pending !== true;
+    return waitFor(predicate, opts);
+}
+/**
+ * Wait form is idle (not loading). This need to implement {loading: boolean}
+ * @param form
+ * @param opts
+ */
+export function waitIdle(form, opts) {
+    const predicate = () => form.loading !== true;
+    return waitFor(predicate, opts);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms.js","sourceRoot":"","sources":["../../../../../src/app/shared/forms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,gBAAgB,EAAE,kBAAkB,EAAE,gBAAgB,EAAmB,MAAM,gBAAgB,CAAC;AACzH,OAAO,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAsB,eAAe,EAAY,eAAe,EAAC,MAAM,aAAa,CAAC;AAC5F,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AACxC,OAAO,EAAC,OAAO,EAAiB,MAAM,eAAe,CAAC;AAOtD;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,MAAW,EAAE,MAAwB,EAAE,IAAkD;IACvH,MAAM,IAAI,GAAG,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpD,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,MAAqB,EAAE,IAAsB;IAClF,OAAO,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAA2B,CAAC;AACrE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB,EAAE,OAAwB,EAAE,IAAa;IAChG,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAE1C,aAAa;IACb,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,wCAAwC;QACxC,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,QAAQ,EAAE;YAClC,MAAM,CAAC,GAAG,CAAC,GAAG,mBAAmB,CAAC,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,GAAG,CAAC,CAAC;SACnG;QACD,OAAO,MAAM,CAAC;KACf;IAED,QAAQ;IACR,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAEvC,oCAAoC;QACpC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;YAC9B,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SAC5B;QAED,gCAAgC;QAChC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YAClD,IAAI,eAAe,CAAC,MAAM,CAAC;gBAAE,OAAO,CAAC,IAAI,CAAC,sCAAsC,IAAI,yCAAyC,CAAC,CAAC;YAC/H,OAAO,EAAE,CAAC;SACX;QAED,qCAAqC;QACrC,MAAM,gBAAgB,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACvC,IAAI,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,UAAU,GAAG,GAAG,GAAG,KAAK,CAAC,CAAU,CAAC;QAEzH,8BAA8B;QAC9B,IAAI,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE;YAClC,IAAI,gBAAgB,YAAY,kBAAkB,EAAE;gBAClD,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACnD,OAAO,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC;iBACxE;aACF;iBACI;gBACH,OAAO,CAAC,IAAI,CAAC,sCAAsC,IAAI,IAAE,EAAE,yCAAyC,CAAC,CAAC;gBACtG,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;aAC1C;SACF;QAED,4BAA4B;aACvB,IAAI,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE;YACvC,0DAA0D;YAC1D,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACnD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACnB;SACF;QACD,OAAO,MAAM,CAAC;KACf;IAED,eAAe;IACf,IAAI,OAAO,YAAY,kBAAkB,EAAE;QACzC,OAAO;QACP,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;YACpB,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;SAChC;QACD,qDAAqD;QACrD,uDAAuD;aAClD;YACH,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;SAChC;KACF;AAEH,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,OAAwB,EAAE,SAAkB,EAAE,IAAa;IACvF,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK;QAAE,OAAO;IACtC,SAAS,GAAG,SAAS,IAAI,EAAE,CAAC;IAC5B,aAAa;IACb,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,IAAI,CAAC,IAAI;YAAE,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,eAAe,CAAC,CAAC;QACrD,IAAI,OAAO,CAAC,MAAM,EAAE;YAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAC1C,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,OAAO,IAAI,IAAI,EAAE,KAAK,KAAK,GAAG,CAAC,CACzD,CAAC;SACH;QACD,IAAI,OAAO,CAAC,QAAQ,EAAE;YACpB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAC5C,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB;aACzG,CAAC;SACH;KACF;IACD,aAAa;SACR,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAC5C,IAAI,OAAO,CAAC,MAAM,EAAE;YAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAC1C,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,OAAO,IAAI,IAAI,EAAE,KAAK,KAAK,GAAG,CAAC,CACzD,CAAC;SACH;QACD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACxC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,iBAAiB;QAC9F,CAAC,CAAC,CAAC;KACJ;IACD,yBAAyB;SACpB,IAAI,OAAO,CAAC,MAAM,EAAE;QACvB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAC1C,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,OAAO,IAAI,IAAI,EAAE,KAAK,KAAK,GAAG,CAAC,CACzD,CAAC;KACH;AACH,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,OAAwB,EAAE,IAIvD;IACC,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAEhD,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;IAEhC,aAAa;IACb,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,cAAc;QACd,IAAI,OAAO,CAAC,MAAM,EAAE;YAClB,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG;oBAC9B,GAAG,OAAO,CAAC,MAAM;iBAClB,CAAC;aACH;iBACI;gBACH,IAAI,CAAC,MAAM,GAAG;oBACZ,GAAG,IAAI,CAAC,MAAM;oBACd,GAAG,OAAO,CAAC,MAAM;iBAClB,CAAC;aACH;SACF;QAED,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;YACrC,4BAA4B;YAC5B,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,QAAQ,EAAE;gBAClC,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBACpC,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO,EAAE;oBAC1B,aAAa,CAAC,KAAK,EAAE;wBACnB,GAAG,IAAI;wBACP,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG;wBACvE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,2CAA2C;qBAChE,CAAC,CAAC;iBACJ;aACF;SACF;KACF;IAED,aAAa;SACR,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACxC,aAAa,CAAC,KAAK,EAAE;gBACnB,GAAG,IAAI;gBACP,WAAW,EAAE,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,GAAG,GAAG,GAAG,KAAK;gBACnD,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,2CAA2C;aAChE,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;KACJ;IAED,6CAA6C;SACxC,IAAI,OAAO,CAAC,MAAM,EAAE;QACvB,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG;gBAC9B,GAAG,OAAO,CAAC,MAAM;aAClB,CAAC;SACH;aACI;YACH,IAAI,CAAC,MAAM,GAAG;gBACZ,GAAG,IAAI,CAAC,MAAM;gBACd,GAAG,OAAO,CAAC,MAAM;aAClB,CAAC;SACH;KACF;IACD,OAAO,IAAI,CAAC,MAAM,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAsB,EAAE,IAAY;IACrE,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;KAC5B;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACjC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,gBAAgB,EAAE;QAClD,OAAO,kBAAkB,CAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAsB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC5F;IACD,MAAM,IAAI,KAAK,CAAC,uBAAuB,GAAG,2BAA2B,CAAC,CAAC;AACzE,CAAC;AAGD,MAAM,UAAU,eAAe,CAAC,IAAsB,EAAE,KAAe,EAAE,IAAiD;IACxH,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;QAC3B,MAAM,OAAO,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/C,IAAI,OAAO;YAAE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACL,CAAC;AAGD,MAAM,UAAU,eAAe,CAAC,YAA8B,EAC9B,aAA+C,EAC/C,MAAqC,EACrC,OAAgC,EAChC,KAAU,EACV,OAAgC;IAC9D,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;IAEvC,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC;IAEf,iCAAiC;IACjC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;QACnB,KAAK,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;KACrE;IAED,uDAAuD;IACvD,IAAI,KAAK,KAAK,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE;QAClG,KAAK,GAAG,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;KACjC;IAED,6BAA6B;IAC7B,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;QAChB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACnB,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAClD,UAAU,GAAG,IAAI,CAAC;SACnB;KACF;SAAM;QACL,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QAErC,gEAAgE;QAChE,kDAAkD;QAClD,IAAI,QAAQ,IAAI,OAAO,CAAC,OAAO;YAAE,OAAO,CAAC,OAAO,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;aAC/D,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;YAAE,OAAO,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;QAE1E,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACpC,UAAU,GAAG,IAAI,CAAC;KACnB;IAED,IAAI,UAAU,EAAE;QACd,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE;YAC3C,2BAA2B;YAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACnB,YAAY,CAAC,WAAW,EAAE,CAAC;aAC5B;SACF;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,YAA8B,EAC9B,aAA+C,EAC/C,aAAoB,EACpB,OAA+B;IACzE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,aAAa,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,kBAAkB;IAEjH,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;IAEvC,OAAO,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;QAC9B,YAAY,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;KACzD;IAED,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;QACpC,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QAErC,gEAAgE;QAChE,kDAAkD;QAClD,IAAI,QAAQ,IAAI,OAAO,CAAC,OAAO;YAAE,OAAO,CAAC,OAAO,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;aAC/D,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;YAAE,OAAO,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;QAE1E,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC,CAAC,mBAAmB;AAClC,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,YAA8B,EAC9B,aAAoC,EACpC,MAAc,EACd,OAA+B;IACzD,IAAI,YAAY,CAAC,MAAM,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC,CAAC,kBAAkB;IAEpE,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;IAEvC,cAAc;IACd,OAAO,YAAY,CAAC,MAAM,GAAG,MAAM,EAAE;QACnC,YAAY,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;KACzD;IAED,gBAAgB;IAChB,OAAO,YAAY,CAAC,MAAM,GAAG,MAAM,EAAE;QACnC,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;QAEhC,gEAAgE;QAChE,+EAA+E;QAC/E,IAAI,QAAQ,IAAI,OAAO,CAAC,OAAO;YAAE,OAAO,CAAC,OAAO,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAA;aAC/D,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;YAAE,OAAO,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,KAAK,EAAC,CAAC,CAAC;QAE3E,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;KACrC;IAED,OAAO,IAAI,CAAC,CAAC,mBAAmB;AAClC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,YAA8B,EAC9B,OAAgC,EAChC,KAAa;IAC9C,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7B,YAAY,CAAC,WAAW,EAAE,CAAC;IAC3B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,YAA8B,EAC9B,OAAgC,EAChC,KAAa;IAE7C,MAAM,OAAO,GAAG,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,CAAC,2BAA2B;IAErE,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,eAAe,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;KAC9B;SACI,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAC5C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;KACtB;SACI;QACH,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;KACxB;IACD,YAAY,CAAC,WAAW,EAAE,CAAC;IAC3B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,OAAwB,EAAE,IAAiD;IAC1G,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,sBAAsB,CAAC,OAAO,EAAE,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,iBAAiB;KAC9E;SACI,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAC5C,OAAO,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACxC,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC,EAAE,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB;KAC7G;SACI;QACH,OAAO,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACxC,OAAO,CAAC,sBAAsB,CAAC,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;KAC3D;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,IAAsB,EAAE,IAAiD;IAC9G,IAAI,CAAC,IAAI;QAAE,OAAO;IAClB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;SACvB,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC9B,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;SAClC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAC3D,IAAI,CAAC,sBAAsB,CAAC,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAwB,EAAE,IAAiD;IAC9G,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,IAAI,OAAO,YAAY,gBAAgB,EAAE;QACvC,gBAAgB,CAAC,OAAO,EAAE,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,iBAAiB;KACzE;SACI,IAAI,OAAO,YAAY,gBAAgB,EAAE;QAC5C,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC,EAAE,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB;KAC9G;SACI;QACH,OAAO,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACxC,OAAO,CAAC,sBAAsB,CAAC,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;KAC3D;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,IAAsB,EAAE,IAAiD;IAC9G,IAAI,CAAC,IAAI;QAAE,OAAO;IAClB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;SACvB,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC9B,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;SAClC,OAAO,CAAC,OAAO,CAAC,EAAE;QACjB,IAAI,OAAO,YAAY,gBAAgB,EAAE;YACvC,sBAAsB,CAAC,OAAO,EAAE,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,iBAAiB;SAC9E;aACI;YACH,OAAO,CAAC,sBAAsB,CAAC,EAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;SAC3D;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAsB,EAAE,IAA4B;IAClF,IAAI,CAAC,IAAI;QAAE,OAAO;IAClB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC;SACtC,OAAO,CAAC,GAAG,CAAC,EAAE;QACb,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,OAAO,YAAY,gBAAgB,EAAE;YACvC,eAAe,CAAC,OAAO,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC,CAAC,iBAAiB;SAC9D;aACI;YACH,OAAO,CAAC,eAAe,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;YAC1C,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SACzB;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAiC,IAAO,EAAE,IAAqB;IAC7F,MAAM,SAAS,GAAoB,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC;IAC/D,OAAO,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAiC,IAAO,EAAE,IAAqB;IACrF,MAAM,SAAS,GAAoB,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC;IAC/D,OAAO,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import {AbstractControl, UntypedFormArray, UntypedFormControl, UntypedFormGroup, ValidationErrors} from '@angular/forms';\nimport {isMoment} from 'moment';\nimport {isNil, isNilOrBlank, isNotEmptyArray, isNotNil, nullIfUndefined} from './functions';\nimport {toDateISOString} from './dates';\nimport {waitFor, WaitForOptions} from './observables';\nimport {Predicate} from '@angular/core';\n\nexport interface FormErrors {\n  [key: string]: ValidationErrors;\n}\n\n/**\n * Fill a form using a source entity\n *\n * @param target\n * @param entity\n * @param opts\n */\nexport function copyEntity2Form(entity: any, target: UntypedFormGroup, opts?: { emitEvent?: boolean; onlySelf?: boolean }) {\n  const json = getFormValueFromEntity(entity, target);\n  target.patchValue(json, opts);\n}\n\nexport function getFormValueFromEntity(entity: any|undefined, form: UntypedFormGroup): { [key: string]: any } {\n  return adaptValueToControl(entity, form) as { [key: string]: any };\n}\n\n/**\n * Transform an entity into a simple object, compatible with the given form\n *\n * @param source an entity (or subentity)\n * @param control\n * @param path\n */\nexport function adaptValueToControl(source: any|undefined, control: AbstractControl, path?: string): any {\n  const pathPrefix = path ? path + '.' : '';\n\n  // Form group\n  if (control instanceof UntypedFormGroup) {\n    const result = {};\n    // eslint-disable-next-line guard-for-in\n    for (const key in control.controls) {\n      result[key] = adaptValueToControl(source && source[key], control.controls[key], pathPrefix + key);\n    }\n    return result;\n  }\n\n  // Array\n  if (control instanceof UntypedFormArray) {\n\n    // Split, if many values in a string\n    if (typeof source === 'string') {\n      source = source.split('|');\n    }\n\n    // Skip if value is not an array\n    if (!Array.isArray(source) || control.length === 0) {\n      if (isNotEmptyArray(source)) console.warn(`WARN: please resize the FormArray '${path}' to the same length of the input array`);\n      return [];\n    }\n\n    // Use the first form group, as model\n    const firstItemControl = control.at(0);\n    let result = source.map((item, index) => adaptValueToControl(item, firstItemControl, pathPrefix + '#' + index)) as any[];\n\n    // Truncate if too many values\n    if (result.length > control.length) {\n      if (firstItemControl instanceof UntypedFormControl) {\n        for (let i = control.length; i < result.length; i++) {\n          control.push(new UntypedFormControl(null, firstItemControl.validator));\n        }\n      }\n      else {\n        console.warn(`WARN: please resize the FormArray '${path||''}' to the same length of the input array`);\n        result = result.slice(0, control.length);\n      }\n    }\n\n    // Add values if not enought\n    else if (result.length < control.length) {\n      //console.warn(`WARN: Adding null value to array values`);\n      for (let i = result.length; i < control.length; i++) {\n        result.push(null);\n      }\n    }\n    return result;\n  }\n\n  // Form control\n  if (control instanceof UntypedFormControl) {\n    // Date\n    if (isMoment(source)) {\n      return toDateISOString(source);\n    }\n    // Any other control: replace undefined by null value\n    // because Undefined is not authorized as control value\n    else {\n      return nullIfUndefined(source);\n    }\n  }\n\n}\n\nexport function logFormErrors(control: AbstractControl, logPrefix?: string, path?: string) {\n  if (!control || control.valid) return;\n  logPrefix = logPrefix || '';\n  // Form group\n  if (control instanceof UntypedFormGroup) {\n    if (!path) console.warn(`${logPrefix} Form errors:`);\n    if (control.errors) {\n      Object.keys(control.errors).forEach(error =>\n        console.warn(`${logPrefix} -> ${path || ''} (${error})`)\n      );\n    }\n    if (control.controls) {\n      Object.keys(control.controls).forEach(child =>\n        logFormErrors(control.controls[child], logPrefix, (path ? `${path}.${child}` : child)) // Recursive call\n      );\n    }\n  }\n  // Form array\n  else if (control instanceof UntypedFormArray) {\n    if (control.errors) {\n      Object.keys(control.errors).forEach(error =>\n        console.warn(`${logPrefix} -> ${path || ''} (${error})`)\n      );\n    }\n    control.controls.forEach((child, index) => {\n      logFormErrors(child, logPrefix, (path ? `${path}.${index}` : `${index}`)); // Recursive call\n    });\n  }\n  // Other control's errors\n  else if (control.errors) {\n    Object.keys(control.errors).forEach(error =>\n      console.warn(`${logPrefix} -> ${path || ''} (${error})`)\n    );\n  }\n}\n\nexport function getFormErrors(control: AbstractControl, opts?: {\n  controlName?: string;\n  result?: FormErrors;\n  recursive?: boolean;\n}): FormErrors {\n  if (!control || control.valid) return undefined;\n\n  opts = opts || {};\n  opts.result = opts.result || {};\n\n  // Form group\n  if (control instanceof UntypedFormGroup) {\n    // Copy errors\n    if (control.errors) {\n      if (opts.controlName) {\n        opts.result[opts.controlName] = {\n          ...control.errors\n        };\n      }\n      else {\n        opts.result = {\n          ...opts.result,\n          ...control.errors\n        };\n      }\n    }\n\n    if (!opts || opts.recursive !== false) {\n      // Loop on children controls\n      for (const key in control.controls) {\n        const child = control.controls[key];\n        if (child && child.enabled) {\n          getFormErrors(child, {\n            ...opts,\n            controlName: opts.controlName ? [opts.controlName, key].join('.') : key,\n            result: opts.result // Make sure to keep the same result object\n          });\n        }\n      }\n    }\n  }\n\n  // Form array\n  else if (control instanceof UntypedFormArray) {\n    control.controls.forEach((child, index) => {\n      getFormErrors(child, {\n        ...opts,\n        controlName: (opts.controlName || '') + '.' + index,\n        result: opts.result // Make sure to keep the same result object\n      });\n    });\n  }\n\n  // Other type of control (e.g simple control)\n  else if (control.errors) {\n    if (opts.controlName) {\n      opts.result[opts.controlName] = {\n        ...control.errors\n      };\n    }\n    else {\n      opts.result = {\n        ...opts.result,\n        ...control.errors\n      };\n    }\n  }\n  return opts.result;\n}\n\nexport function getControlFromPath(form: UntypedFormGroup, path: string): AbstractControl {\n  const i = path.indexOf('.');\n  if (i === -1) {\n    return form.controls[path];\n  }\n  const key = path.substring(0, i);\n  if (form.controls[key] instanceof UntypedFormGroup) {\n    return getControlFromPath((form.controls[key] as UntypedFormGroup), path.substring(i + 1));\n  }\n  throw new Error(`Invalid form path: '${key}' should be a form group.`);\n}\n\n\nexport function disableControls(form: UntypedFormGroup, paths: string[], opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n  (paths || []).forEach(path => {\n    const control = getControlFromPath(form, path);\n    if (control) control.disable(opts);\n  });\n}\n\n\nexport function addValueInArray(arrayControl: UntypedFormArray,\n                                createControl: (value?: any) => AbstractControl,\n                                equals: (v1: any, v2: any) => boolean,\n                                isEmpty: (value: any) => boolean,\n                                value: any,\n                                options?: { emitEvent: boolean }): boolean {\n  const disabled = arrayControl.disabled;\n\n  let hasChanged = false;\n  let index = -1;\n\n  // Search if value already exists\n  if (!isEmpty(value)) {\n    index = (arrayControl.value || []).findIndex(v => equals(value, v));\n  }\n\n  // If value not exists, but last value is empty: use it\n  if (index === -1 && arrayControl.length && isEmpty(arrayControl.at(arrayControl.length - 1).value)) {\n    index = arrayControl.length - 1;\n  }\n\n  // Replace the existing value\n  if (index !== -1) {\n    if (!isEmpty(value)) {\n      arrayControl.at(index).patchValue(value, options);\n      hasChanged = true;\n    }\n  } else {\n    const control = createControl(value);\n\n    // Apply parent disabled state, before to push it into the array\n    // This is need to avoid parent form to be enabled\n    if (disabled && control.enabled) control.disable({emitEvent: false})\n    else if (!disabled && control.disabled) control.enable({emitEvent: false})\n\n    arrayControl.push(control, options);\n    hasChanged = true;\n  }\n\n  if (hasChanged) {\n    if (!options || options.emitEvent !== false) {\n      // Mark array control dirty\n      if (!isEmpty(value)) {\n        arrayControl.markAsDirty();\n      }\n    }\n  }\n\n  return hasChanged;\n}\n\n/**\n * Set an array using given default values. Each default value will be pass to the 'createControl()' function\n * @param arrayControl\n * @param createControl\n * @param values\n */\nexport function initArrayControlsFromValues(arrayControl: UntypedFormArray,\n                                            createControl: (value?: any) => AbstractControl,\n                                            defaultValues: any[],\n                                            options?: {emitEvent?: boolean}): boolean {\n  if (arrayControl.length === 0 && (!defaultValues || defaultValues.length === 0)) return false; // No changes need\n\n  const disabled = arrayControl.disabled;\n\n  while (arrayControl.length > 0) {\n    arrayControl.removeAt(arrayControl.length - 1, options);\n  }\n\n  (defaultValues || []).forEach(value => {\n    const control = createControl(value);\n\n    // Apply parent disabled state, before to push it into the array\n    // This is need to avoid parent form to be enabled\n    if (disabled && control.enabled) control.disable({emitEvent: false})\n    else if (!disabled && control.disabled) control.enable({emitEvent: false})\n\n    arrayControl.push(control, options);\n  });\n\n  return true; // Has some changes\n}\n\nexport function resizeArray(arrayControl: UntypedFormArray,\n                            createControl: () => AbstractControl,\n                            length: number,\n                            options?: {emitEvent?: boolean}): boolean {\n  if (arrayControl.length === length) return false; // No changes need\n\n  const disabled = arrayControl.disabled;\n\n  // Reduce size\n  while (arrayControl.length > length) {\n    arrayControl.removeAt(arrayControl.length - 1, options);\n  }\n\n  // Increase size\n  while (arrayControl.length < length) {\n    const control = createControl();\n\n    // Apply parent disabled state, before to push it into the array\n    // This is need to avoid parent form to be enabled, after calling resizeArray()\n    if (disabled && control.enabled) control.disable({emitEvent: false})\n    else if (!disabled && control.disabled) control.enable({emitEvent: false});\n\n    arrayControl.push(control, options);\n  }\n\n  return true; // Has some changes\n}\n\nexport function removeValueInArray(arrayControl: UntypedFormArray,\n                                   isEmpty: (value: any) => boolean,\n                                   index: number): boolean {\n  arrayControl.removeAt(index);\n  arrayControl.markAsDirty();\n  return true;\n}\n\nexport function clearValueInArray(arrayControl: UntypedFormArray,\n                                  isEmpty: (value: any) => boolean,\n                                  index: number): boolean {\n\n  const control = arrayControl.at(index);\n  if (isEmpty(control.value)) return false; // skip (not need to clear)\n\n  if (control instanceof UntypedFormGroup) {\n    copyEntity2Form({}, control);\n  }\n  else if (control instanceof UntypedFormArray) {\n    control.setValue([]);\n  }\n  else {\n    control.setValue(null);\n  }\n  arrayControl.markAsDirty();\n  return true;\n}\n\nexport function markAllAsTouched(control: AbstractControl, opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n  if (!control) return;\n  if (control instanceof UntypedFormGroup) {\n    markFormGroupAsTouched(control, {...opts, onlySelf: true}); // recursive call\n  }\n  else if (control instanceof UntypedFormArray) {\n    control.markAsTouched({onlySelf: true});\n    (control.controls || []).forEach(c => markControlAsTouched(c, {...opts, onlySelf: true})); // recursive call\n  }\n  else {\n    control.markAsTouched({onlySelf: true});\n    control.updateValueAndValidity({...opts, onlySelf: true});\n  }\n}\n\nexport function markFormGroupAsTouched(form: UntypedFormGroup, opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n  if (!form) return;\n  form.markAsTouched(opts);\n  Object.keys(form.controls)\n    .map(key => form.controls[key])\n    .filter(control => control.enabled)\n    .forEach(control => markControlAsTouched(control, opts));\n  form.updateValueAndValidity({...opts, onlySelf: true});\n}\n\nexport function markControlAsTouched(control: AbstractControl, opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n  if (!control) return;\n  if (control instanceof UntypedFormGroup) {\n    markAllAsTouched(control, { ...opts, onlySelf: true}); // recursive call\n  }\n  else if (control instanceof UntypedFormArray) {\n    (control.controls || []).forEach(c => markControlAsTouched(c, { ...opts, onlySelf: true})); // recursive call\n  }\n  else {\n    control.markAsTouched({onlySelf: true});\n    control.updateValueAndValidity({...opts, onlySelf: true});\n  }\n}\n\nexport function updateValueAndValidity(form: UntypedFormGroup, opts?: {onlySelf?: boolean; emitEvent?: boolean }) {\n  if (!form) return;\n  form.updateValueAndValidity(opts);\n  Object.keys(form.controls)\n    .map(key => form.controls[key])\n    .filter(control => control.enabled)\n    .forEach(control => {\n      if (control instanceof UntypedFormGroup) {\n        updateValueAndValidity(control, {...opts, onlySelf: true}); // recursive call\n      }\n      else {\n        control.updateValueAndValidity({...opts, onlySelf: true});\n      }\n    });\n}\n\nexport function markAsUntouched(form: UntypedFormGroup, opts?: {onlySelf?: boolean }) {\n  if (!form) return;\n  form.markAsUntouched(opts);\n  Object.getOwnPropertyNames(form.controls)\n    .forEach(key => {\n      const control = form.get(key);\n      if (control instanceof UntypedFormGroup) {\n        markAsUntouched(control, {onlySelf: true}); // recursive call\n      }\n      else {\n        control.markAsUntouched({onlySelf: true});\n        control.setErrors(null);\n      }\n    });\n}\n\n/**\n * Wait end of async validation (not pending). This need to implement {pending: boolean}\n * return false\n */\nexport function waitWhilePending<T extends { pending: boolean }>(form: T, opts?: WaitForOptions): Promise<void> {\n  const predicate: Predicate<void> = () => form.pending !== true;\n  return waitFor(predicate, opts);\n}\n\n/**\n * Wait form is idle (not loading). This need to implement {loading: boolean}\n * @param form\n * @param opts\n */\nexport function waitIdle<T extends { loading: boolean }>(form: T, opts?: WaitForOptions): Promise<void> {\n  const predicate: Predicate<void> = () => form.loading !== true;\n  return waitFor(predicate, opts);\n}\n"]}