@sumaris-net/ngx-components 3.0.0-rc1 → 4.0.0-rc10

package/esm2022/src/app/shared/validator/validators.mjs

@@ -0,0 +1,580 @@
+import { AbstractControl } from '@angular/forms';
+import { isMoment } from 'moment';
+import { PUBKEY_REGEXP } from '../constants';
+import { isEmptyArray, isNil, isNilOrBlank, isNotNil, isNotNilOrBlank, isNotNilOrNaN, toBoolean, toNumber } from '../functions';
+import { fromDateISOString } from '../dates';
+import { from, isObservable, merge, of, Subject, Subscription, timer } from 'rxjs';
+import { catchError, first, switchMap, takeUntil, tap } from 'rxjs/operators';
+// @dynamic
+export class SharedValidators {
+    static _DOUBLE_REGEXP_CACHE = {
+        NO_LIMIT: /^-?\d+([.,]\d*)?$/,
+        1: /^-?\d+([.,]\d)?$/,
+        2: /^-?\d+([.,]\d{1,2})?$/,
+        3: /^-?\d+([.,]\d{1,3})?$/ // 3 decimals max
+    };
+    static getDoubleRegexp(maxDecimals) {
+        if (isNil(maxDecimals))
+            return this._DOUBLE_REGEXP_CACHE.NO_LIMIT;
+        if (maxDecimals < 0)
+            throw new Error(`Invalid maxDecimals value: ${maxDecimals}`);
+        const regexp = this._DOUBLE_REGEXP_CACHE[maxDecimals];
+        if (regexp)
+            return regexp;
+        // New: add to cache
+        this._DOUBLE_REGEXP_CACHE[maxDecimals] = new RegExp(`^-?\\d+([.,]\\d{1,${maxDecimals}})?$`);
+        return this._DOUBLE_REGEXP_CACHE[maxDecimals];
+    }
+    static I18N_ERROR_KEYS = {
+        required: 'ERROR.FIELD_REQUIRED',
+        min: 'ERROR.FIELD_MIN',
+        max: 'ERROR.FIELD_MAX',
+        minlength: 'ERROR.FIELD_MIN_LENGTH',
+        maxlength: 'ERROR.FIELD_MAX_LENGTH',
+        pubkey: 'ERROR.FIELD_NOT_VALID_PUBKEY',
+        validDate: 'ERROR.FIELD_NOT_VALID_DATE',
+        dateIsAfter: 'ERROR.FIELD_NOT_VALID_DATE_AFTER',
+        dateIsBefore: 'ERROR.FIELD_NOT_VALID_DATE_BEFORE',
+        dateRange: 'ERROR.FIELD_NOT_VALID_DATE_RANGE',
+        dateMinDuration: 'ERROR.FIELD_NOT_VALID_DATE_MIN_DURATION',
+        dateMaxDuration: 'ERROR.FIELD_NOT_VALID_DATE_MAX_DURATION',
+        maxDecimals: 'ERROR.FIELD_MAXIMUM_DECIMALS',
+        double: 'ERROR.FIELD_NOT_VALID_DOUBLE',
+        integer: 'ERROR.FIELD_NOT_VALID_INTEGER',
+        precision: 'ERROR.FIELD_NOT_VALID_PRECISION',
+        email: 'ERROR.FIELD_NOT_VALID_EMAIL',
+        latitude: 'ERROR.FIELD_NOT_VALID_LATITUDE',
+        longitude: 'ERROR.FIELD_NOT_VALID_LONGITUDE',
+        pattern: 'ERROR.FIELD_NOT_VALID_PATTERN',
+        unique: 'ERROR.FIELD_NOT_UNIQUE',
+        entity: 'ERROR.FIELD_INVALID'
+    };
+    static latitude(control) {
+        const value = control.value;
+        if (isNotNil(value) && (value < -90 || value > 90)) {
+            return { latitude: true };
+        }
+        return null;
+    }
+    static longitude(control) {
+        const value = control.value;
+        if (isNotNil(value) && (value < -180 || value > 180)) {
+            return { longitude: true };
+        }
+        return null;
+    }
+    static object(control) {
+        const value = control.value;
+        if (value && typeof value !== 'object') {
+            return { object: true };
+        }
+        return null;
+    }
+    static entity(control) {
+        const value = control.value;
+        if (value && (typeof value !== 'object' || value.id === undefined || value.id === null)) {
+            return { entity: true };
+        }
+        return null;
+    }
+    static empty(control) {
+        if (isNotNilOrBlank(control.value)) {
+            return { empty: true };
+        }
+        return null;
+    }
+    static pubkey(control) {
+        const value = control.value;
+        if (value && (typeof value !== 'string' || !PUBKEY_REGEXP.test(value))) {
+            return { pubkey: true };
+        }
+        return null;
+    }
+    static integer(control) {
+        if (isNilOrBlank(control.value))
+            return null;
+        const value = parseFloat(control.value);
+        if (isNaN(value) || (value | 0) !== value) {
+            return { integer: true };
+        }
+        return null;
+    }
+    /**
+     * @deprecated use decimal
+     */
+    static double = SharedValidators.decimal;
+    static decimal(opts) {
+        const regexp = this.getDoubleRegexp(opts?.maxDecimals);
+        return (control) => {
+            const value = control.value;
+            if (Number.isNaN(value)) {
+                // DEBUG
+                //console.debug("WARN: Getting a NaN value (decimal was expected) !");
+                return null;
+            }
+            if (isNotNil(value) && value !== '' && !regexp.test(value)) {
+                return isNotNil(opts?.maxDecimals) ? { maxDecimals: { maxDecimals: opts.maxDecimals } } : { decimal: true };
+            }
+            return null;
+        };
+    }
+    /**
+     * Check precision. e.g. if precision=0.5 then value=0.6 is invalid, but 1.5 is valid
+     *
+     * @param precision
+     */
+    static precision(precision) {
+        if (isNil(precision))
+            throw new Error('Required a not nil precision');
+        // WARN: we should define a multiplier, because modulo in javascript will only work on integer
+        // (e.g. "7 % 0.1" in javascript will NOT return zero (but 0.09999999999999962)
+        const precisionNbDecimals = (precision.toString().split('.')[1] || '').length;
+        const multiplier = Math.pow(10, precisionNbDecimals);
+        const multipliedPrecision = Math.round(multiplier * precision);
+        // The validator function
+        return (control) => {
+            const value = control.value;
+            if (isNilOrBlank(value) || Number.isNaN(value)) {
+                return null;
+            }
+            // WARN: Convert value into integer, before applying modulo operator
+            const mod = Math.round(+value * multiplier) % multipliedPrecision;
+            if (mod !== 0) {
+                // DEBUG
+                //console.debug(`WARN Getting a ${value} with an invalid precision (expected precision is: ${precision})`);
+                return { precision: { precision } };
+            }
+            return null;
+        };
+    }
+    static validDate(control) {
+        const value = control.value;
+        const date = !value || isMoment(value) ? value : fromDateISOString(value);
+        if (date && (!date.isValid() || date.year() < 1900)) {
+            return { validDate: true };
+        }
+        return null;
+    }
+    static dateIsAfter(previousValue, errorParam, granularity) {
+        return (control) => {
+            const value = fromDateISOString(control.value);
+            if (isNotNil(value) && isNotNil(previousValue) && value.isSameOrBefore(previousValue, granularity)) {
+                // Return the error
+                return { dateIsAfter: { minDate: errorParam } };
+            }
+            return null;
+        };
+    }
+    static dateIsBefore(maxValue, errorParam, granularity) {
+        return (control) => {
+            const value = fromDateISOString(control.value);
+            if (isNotNil(value) && isNotNil(maxValue) && value.isSameOrAfter(maxValue, granularity)) {
+                // Return the error
+                return { dateIsBefore: { maxDate: errorParam } };
+            }
+            return null;
+        };
+    }
+    static dateRangeEnd(startDateFieldName, msg) {
+        const errorCode = msg ? 'msg' : 'dateRange';
+        const error = msg ? { msg } : { dateRange: true };
+        return (control) => {
+            // Form group not created yet: skip
+            if (!control.parent)
+                return null;
+            const startControl = control.parent.get(startDateFieldName);
+            if (!startControl) {
+                console.warn(`Cannot find brother control '${startDateFieldName}' in the parent form`);
+                return null;
+            }
+            const startDate = fromDateISOString(startControl.value);
+            const endDate = fromDateISOString(control.value);
+            // Error if value <= beforeDate
+            if (isNotNil(endDate) && isNotNil(startDate) && endDate.isSameOrBefore(startDate)) {
+                return error;
+            }
+            // OK: clear existing errors
+            SharedValidators.clearError(control, errorCode);
+            return null;
+        };
+    }
+    static dateRangeStart(endDateFieldName, msg) {
+        const errorCode = msg ? 'msg' : 'dateRange';
+        const error = msg ? { msg } : { dateRange: true };
+        return (control) => {
+            // Form group not created yet: skip
+            if (!control.parent)
+                return null;
+            const endDateControl = control.parent.get(endDateFieldName);
+            if (!endDateControl) {
+                console.warn(`Cannot find control '${endDateFieldName}' in the parent form`);
+                return null;
+            }
+            const endDate = fromDateISOString(endDateControl.value);
+            const startDate = fromDateISOString(control.value);
+            // Error if value <= beforeDate
+            if (isNotNil(startDate) && isNotNil(endDate) && startDate.isSameOrAfter(endDate)) {
+                return error;
+            }
+            // OK: clear existing errors
+            SharedValidators.clearError(control, errorCode);
+            return null;
+        };
+    }
+    static copyParentErrors(errorNames) {
+        return (control) => {
+            // Skip if control already has some errors
+            if (control.errors)
+                return null;
+            // Skip if parent form group not created yet
+            if (!control.parent)
+                return null;
+            // Form group not created yet
+            if (!control.parent)
+                return null;
+            const errors = control.parent.errors;
+            // No errors, or copy all errors
+            if (!errors || isEmptyArray(errorNames))
+                return errors;
+            // Copy only expected errors
+            return Object.keys(errors).reduce((res, key) => {
+                if (errorNames.includes(key)) {
+                    res[key] = errors[key];
+                }
+                return res;
+            }, {});
+        };
+    }
+    static clearError(control, errorCode) {
+        if (control.hasError(errorCode)) {
+            const errors = control.errors;
+            if (errors && errors[errorCode]) {
+                // Only one error: reset errors
+                if (Object.getOwnPropertyNames(errors).length === 1) {
+                    control.setErrors(null);
+                }
+                // Other errors exists: just remove this error
+                else {
+                    delete errors[errorCode];
+                    control.setErrors(errors);
+                }
+            }
+        }
+    }
+}
+// @dynamic
+export class SharedFormGroupValidators {
+    static dateRange(startDateField, endDateField, msg) {
+        const errorCode = isNotNilOrBlank(msg) ? 'msg' : 'dateRange';
+        const rangeError = msg ? { msg } : { dateRange: true };
+        return (group) => {
+            const startDate = fromDateISOString(group.get(startDateField).value);
+            const endField = group.get(endDateField);
+            const endDate = fromDateISOString(endField.value);
+            if (isNotNil(startDate) && isNotNil(endDate) && startDate.isAfter(endDate)) {
+                // Update end field
+                endField.markAsPending();
+                endField.setErrors({
+                    ...endField.errors,
+                    ...rangeError
+                });
+                // Return the error (should be apply to the parent form)
+                return rangeError;
+            }
+            // OK: remove the existing on the end field
+            SharedValidators.clearError(endField, errorCode);
+            return null;
+        };
+    }
+    static dateMaxDuration(startDateField, endDateField, maxDuration, durationUnit) {
+        const maxDurationError = { dateMaxDuration: true };
+        return (group) => {
+            const startDate = fromDateISOString(group.get(startDateField).value);
+            const endField = group.get(endDateField);
+            const endDate = fromDateISOString(endField.value);
+            if (isNotNil(startDate) && isNotNil(endDate) && Math.abs(startDate.diff(endDate, durationUnit)) > maxDuration) {
+                // Update end field
+                endField.markAsTouched({ onlySelf: true });
+                endField.markAsPending();
+                endField.setErrors({
+                    ...endField.errors,
+                    ...maxDurationError
+                });
+                // Return the error (should be apply to the parent form)
+                return maxDurationError;
+            }
+            // OK: remove the existing on the end field
+            SharedValidators.clearError(endField, 'dateMaxDuration');
+            return null;
+        };
+    }
+    static dateMinDuration(startDateField, endDateField, minDuration, durationUnit) {
+        return (group) => {
+            const endField = group.get(endDateField);
+            const startDate = fromDateISOString(group.get(startDateField).value);
+            const endDate = fromDateISOString(endField.value);
+            if (isNotNil(startDate) && isNotNil(endDate) && Math.abs(startDate.diff(endDate, durationUnit)) < minDuration) {
+                // Update end field
+                const endFieldErrors = endField.errors || {};
+                endFieldErrors['dateMinDuration'] = true;
+                endField.setErrors(endFieldErrors);
+                endField.markAsTouched({ onlySelf: true });
+                // Return the error (should be apply to the parent form)
+                return { dateMinDuration: true };
+            }
+            // OK: remove the existing on the end field
+            else {
+                SharedValidators.clearError(endField, 'dateMinDuration');
+            }
+            return null;
+        };
+    }
+    static requiredIf(fieldName, anotherFieldToCheck) {
+        return (group) => {
+            const control = group.get(fieldName);
+            const anotherControl = (anotherFieldToCheck instanceof AbstractControl) ? anotherFieldToCheck : group.get(anotherFieldToCheck);
+            if (!anotherControl)
+                throw new Error('Unable to find field to check!');
+            if (isNilOrBlank(control.value) && isNotNilOrBlank(anotherControl.value)) {
+                const error = { required: true };
+                control.setErrors(error);
+                control.markAsTouched({ onlySelf: true });
+                return error;
+            }
+            SharedValidators.clearError(control, 'required');
+            return null;
+        };
+    }
+    static requiredIfTrue(fieldName, anotherFieldToCheck) {
+        return (group) => {
+            const control = group.get(fieldName);
+            const anotherControl = (anotherFieldToCheck instanceof AbstractControl) ? anotherFieldToCheck : group.get(anotherFieldToCheck);
+            if (!anotherControl)
+                throw new Error('Unable to find field to check!');
+            if (isNilOrBlank(control.value) && toBoolean(anotherControl.value, false)) {
+                const error = { required: true };
+                control.setErrors(error);
+                control.markAsTouched({ onlySelf: true });
+                return error;
+            }
+            SharedValidators.clearError(control, 'required');
+            return null;
+        };
+    }
+    static requiredIfEmpty(fieldName, anotherFieldToCheck) {
+        return (group) => {
+            const control = group.get(fieldName);
+            if (isNilOrBlank(control.value) && isNilOrBlank(group.get(anotherFieldToCheck).value)) {
+                const error = { required: true };
+                control.setErrors(error);
+                control.markAsTouched({ onlySelf: true });
+                return error;
+            }
+            SharedValidators.clearError(control, 'required');
+            return null;
+        };
+    }
+    static propagateIfDirty(fieldName, fieldNameToPropagate, valueToPropagate) {
+        return (group) => {
+            const control = group.get(fieldName);
+            const controlToPropagate = group.get(fieldNameToPropagate);
+            if (control.dirty && controlToPropagate.value !== valueToPropagate) {
+                controlToPropagate.setValue(valueToPropagate);
+            }
+            return null;
+        };
+    }
+    /**
+     * Same as compose, but keep only the first errors (instead of the union)
+     *
+     * @param validators
+     */
+    first(validators) {
+        return (control) => validators
+            .filter(isNotNil)
+            .map(validator => validator(control))
+            .find(isNotNil) || null;
+    }
+}
+// @dynamic
+export class SharedFormArrayValidators {
+    /**
+     * Validate uniqueness of an entity in a FormArray
+     *
+     * @param controlName the name of the control in FormArray
+     */
+    static uniqueEntity(controlName) {
+        return (array) => {
+            const controls = [];
+            if (array.length) {
+                // gather controls in array with valid entity
+                for (const control of array.controls) {
+                    const fromGroup = control;
+                    if (fromGroup.controls[controlName]) {
+                        const value = fromGroup.controls[controlName].value;
+                        if (!!value && !!value.id)
+                            controls.push(fromGroup.controls[controlName]);
+                    }
+                }
+                // get occurrences of entity by id
+                const occurrences = controls.reduce((acc, control) => {
+                    const id = control.value.id;
+                    if (acc[id])
+                        acc[id]++;
+                    else
+                        acc[id] = 1;
+                    return acc;
+                }, {});
+                // get controls with value occurrences > 1
+                const error = { uniqueEntity: true };
+                let returnError = false;
+                controls.filter(control => occurrences[control.value.id] > 1)
+                    .forEach(control => {
+                    let errors = control.errors || {};
+                    errors = { ...errors, ...error };
+                    control.setErrors(errors);
+                    control.markAsTouched({ onlySelf: true });
+                    returnError = true;
+                });
+                if (returnError)
+                    return error;
+            }
+            controls.forEach(control => SharedValidators.clearError(control, 'uniqueEntity'));
+            return null;
+        };
+    }
+    static requiredArrayMinLength(minLength) {
+        minLength = minLength || 1;
+        return (array) => {
+            if (!array || array.length < minLength) {
+                return { required: true };
+            }
+            return null;
+        };
+    }
+    /**
+     * Validate the sum of control values in an FormArray not overflow the max value
+     *
+     * @param controlName the name of the control in FormArray
+     * @param max the maximum value
+     */
+    static validSumMaxValue(controlName, max) {
+        return (array) => {
+            const controls = [];
+            if (array.length) {
+                for (const control of array.controls) {
+                    const fromGroup = control;
+                    if (fromGroup.controls[controlName] && isNotNilOrNaN(fromGroup.controls[controlName].value)) {
+                        controls.push(fromGroup.controls[controlName]);
+                    }
+                }
+                if (controls.reduce((sum, control) => sum + control.value, 0) > max) {
+                    const error = { sumMaxValue: true };
+                    controls.forEach(control => {
+                        let errors = control.errors || {};
+                        errors = { ...errors, ...error };
+                        control.setErrors(errors);
+                        control.markAsTouched({ onlySelf: true });
+                    });
+                    return error;
+                }
+            }
+            controls.forEach(control => SharedValidators.clearError(control, 'sumMaxValue'));
+            return null;
+        };
+    }
+}
+// @dynamic
+export class SharedAsyncValidators {
+    static DEBOUNCE_TIME_VALIDATOR_ID = 0;
+    /**
+     * Add a debounce time to a validator.
+     *
+     * @param form
+     * @param validatorFn
+     * @param opts Use opts.stopSubject to stop the validator, before end
+     */
+    static debounceTime(validatorFn, opts) {
+        // DEBUG only
+        const debug = opts?.debug || false;
+        const logPrefix = debug && `[debounceTime-validator] #${SharedAsyncValidators.DEBOUNCE_TIME_VALIDATOR_ID++} - `;
+        const debounceTime = toNumber(opts?.debounceTime, 250);
+        // DEBUG
+        if (debug)
+            console.debug(logPrefix + `New validator with a debounceTime at ${debounceTime}ms`);
+        const $disposeSubject = new Subject();
+        const disposeEvent$ = opts?.dispose
+            ? merge($disposeSubject, opts?.dispose)
+            : $disposeSubject;
+        // DEBUG
+        if (debug && opts?.dispose) {
+            opts?.dispose.pipe(first()).subscribe(() => {
+                console.debug(logPrefix + 'Stopping');
+            });
+        }
+        return (control) => {
+            if (debug)
+                console.debug(logPrefix + 'Form ask validation...');
+            // Stop previous observables
+            $disposeSubject.next();
+            let now;
+            // Add a delay before execution
+            return timer(debounceTime)
+                .pipe(
+            // DEBUG
+            tap(_ => {
+                if (debug) {
+                    console.debug(logPrefix + 'Executing...');
+                    now = Date.now();
+                }
+            }), switchMap((_) => {
+                // Call the validator
+                const res = validatorFn(control);
+                // Make sure to return an Observable
+                if (isObservable(res))
+                    return res;
+                if (res instanceof Promise)
+                    return from(res);
+                return of(res);
+            }), 
+            // DEBUG
+            tap(res => debug && console.debug(logPrefix + `Finished in ${Date.now() - now}ms (${res ? 'with errors' : 'no error'})`, res)), catchError(error => {
+                console.error('[debounceTime-validator] Error while executing validator. Stopping job', error);
+                $disposeSubject.next();
+                throw error;
+            }), 
+            // Refresh UI, after a successful execution
+            tap(() => opts?.markForCheck && opts?.markForCheck()), 
+            // Make sure to stop, because of the switchMap
+            takeUntil(disposeEvent$));
+        };
+    }
+    /**
+     * Add an async validator, that can be disposed by the returned subscription
+     *
+     * @param form
+     * @param validatorFn the validator or job to execute
+     * @param opts
+     */
+    static registerAsyncValidator(form, validatorFn, opts) {
+        if (form.asyncValidator)
+            throw Error('Form already have an async validator. Cannot configure job');
+        const debounceTime = toNumber(opts?.debounceTime, 250);
+        const $dispose = new Subject();
+        const asyncValidatorFn = SharedAsyncValidators.debounceTime(validatorFn, { ...opts, debounceTime, dispose: $dispose });
+        form.setAsyncValidators(asyncValidatorFn);
+        const subscription = new Subscription();
+        // When unsubscribing, remove async validator
+        subscription.add(() => {
+            // Clear added validator. Must be done NOW (without delay) because generally a new Job is given just after
+            form.clearAsyncValidators();
+            // Stop the job, with a delay to let the last execution finished
+            setTimeout(() => {
+                $dispose.next();
+                $dispose.unsubscribe();
+            }, debounceTime);
+        });
+        return subscription;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../../src/app/shared/validator/validators.ts"],"names":[],"mappings":"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","sourcesContent":["import {AbstractControl, AsyncValidatorFn, UntypedFormArray, UntypedFormControl, UntypedFormGroup, ValidationErrors, ValidatorFn} from '@angular/forms';\nimport {isMoment, Moment, unitOfTime} from 'moment';\nimport {PUBKEY_REGEXP} from '../constants';\nimport {isEmptyArray, isNil, isNilOrBlank, isNotNil, isNotNilOrBlank, isNotNilOrNaN, toBoolean, toNumber} from '../functions';\nimport {fromDateISOString} from '../dates';\nimport {from, isObservable, merge, Observable, of, Subject, Subscription, timer} from 'rxjs';\nimport {catchError, first, switchMap, takeUntil, tap} from 'rxjs/operators';\n\n// @dynamic\nexport class SharedValidators {\n\n  private static _DOUBLE_REGEXP_CACHE = {\n    NO_LIMIT: /^-?\\d+([.,]\\d*)?$/,\n    1: /^-?\\d+([.,]\\d)?$/,         // 1 decimal max\n    2: /^-?\\d+([.,]\\d{1,2})?$/,    // 2 decimals max\n    3: /^-?\\d+([.,]\\d{1,3})?$/     // 3 decimals max\n  };\n\n  private static getDoubleRegexp(maxDecimals: number): RegExp {\n    if (isNil(maxDecimals))\n      return this._DOUBLE_REGEXP_CACHE.NO_LIMIT;\n\n    if (maxDecimals < 0) throw new Error(`Invalid maxDecimals value: ${maxDecimals}`);\n    const regexp = this._DOUBLE_REGEXP_CACHE[maxDecimals];\n    if (regexp) return regexp;\n\n    // New: add to cache\n    this._DOUBLE_REGEXP_CACHE[maxDecimals] = new RegExp(`^-?\\\\d+([.,]\\\\d{1,${maxDecimals}})?$`);\n    return this._DOUBLE_REGEXP_CACHE[maxDecimals];\n  }\n\n\n  static readonly I18N_ERROR_KEYS = {\n    required: 'ERROR.FIELD_REQUIRED',\n    min: 'ERROR.FIELD_MIN',\n    max: 'ERROR.FIELD_MAX',\n    minlength:'ERROR.FIELD_MIN_LENGTH',\n    maxlength:'ERROR.FIELD_MAX_LENGTH',\n    pubkey: 'ERROR.FIELD_NOT_VALID_PUBKEY',\n    validDate: 'ERROR.FIELD_NOT_VALID_DATE',\n    dateIsAfter: 'ERROR.FIELD_NOT_VALID_DATE_AFTER',\n    dateIsBefore: 'ERROR.FIELD_NOT_VALID_DATE_BEFORE',\n    dateRange: 'ERROR.FIELD_NOT_VALID_DATE_RANGE',\n    dateMinDuration: 'ERROR.FIELD_NOT_VALID_DATE_MIN_DURATION',\n    dateMaxDuration: 'ERROR.FIELD_NOT_VALID_DATE_MAX_DURATION',\n    maxDecimals: 'ERROR.FIELD_MAXIMUM_DECIMALS',\n    double: 'ERROR.FIELD_NOT_VALID_DOUBLE',\n    integer: 'ERROR.FIELD_NOT_VALID_INTEGER',\n    precision: 'ERROR.FIELD_NOT_VALID_PRECISION',\n    email: 'ERROR.FIELD_NOT_VALID_EMAIL',\n    latitude: 'ERROR.FIELD_NOT_VALID_LATITUDE',\n    longitude: 'ERROR.FIELD_NOT_VALID_LONGITUDE',\n    pattern: 'ERROR.FIELD_NOT_VALID_PATTERN',\n    unique: 'ERROR.FIELD_NOT_UNIQUE',\n    entity: 'ERROR.FIELD_INVALID'\n  };\n\n  static latitude(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    if (isNotNil(value) && (value < -90 || value > 90)) {\n      return {latitude: true};\n    }\n    return null;\n  }\n\n  static longitude(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    if (isNotNil(value) && (value < -180 || value > 180)) {\n      return {longitude: true};\n    }\n    return null;\n  }\n\n  static object(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    if (value && typeof value !== 'object') {\n      return {object: true};\n    }\n    return null;\n  }\n\n  static entity(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    if (value && (typeof value !== 'object' || value.id === undefined || value.id === null)) {\n      return {entity: true};\n    }\n    return null;\n  }\n\n  static empty(control: UntypedFormControl): ValidationErrors | null {\n    if (isNotNilOrBlank(control.value)) {\n      return {empty: true};\n    }\n    return null;\n  }\n\n  static pubkey(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    if (value && (typeof value !== 'string' || !PUBKEY_REGEXP.test(value))) {\n      return {pubkey: true};\n    }\n    return null;\n  }\n\n  static integer(control: UntypedFormControl): ValidationErrors | null {\n    if (isNilOrBlank(control.value))\n      return null;\n    const value = parseFloat(control.value);\n    if (isNaN(value) || (value | 0) !== value) {\n      return {integer: true};\n    }\n    return null;\n  }\n\n  /**\n   * @deprecated use decimal\n   */\n  static double = SharedValidators.decimal;\n\n  static decimal(opts?: { maxDecimals?: number }): ValidatorFn {\n    const regexp = this.getDoubleRegexp(opts?.maxDecimals);\n    return (control: UntypedFormControl): ValidationErrors | null => {\n      const value = control.value;\n      if (Number.isNaN(value)) {\n        // DEBUG\n        //console.debug(\"WARN: Getting a NaN value (decimal was expected) !\");\n        return null;\n      }\n      if (isNotNil(value) && value !== '' && !regexp.test(value as string)) {\n        return isNotNil(opts?.maxDecimals) ? {maxDecimals: {maxDecimals: opts.maxDecimals} } : {decimal: true};\n      }\n      return null;\n    };\n  }\n\n  /**\n   * Check precision. e.g. if precision=0.5 then value=0.6 is invalid, but 1.5 is valid\n   *\n   * @param precision\n   */\n  static precision(precision: number): ValidatorFn {\n    if (isNil(precision)) throw new Error('Required a not nil precision');\n\n    // WARN: we should define a multiplier, because modulo in javascript will only work on integer\n    // (e.g. \"7 % 0.1\" in javascript will NOT return zero (but 0.09999999999999962)\n    const precisionNbDecimals = (precision.toString().split('.')[1] || '').length;\n    const multiplier = Math.pow(10, precisionNbDecimals);\n    const multipliedPrecision = Math.round(multiplier * precision);\n\n    // The validator function\n    return (control: UntypedFormControl): ValidationErrors | null => {\n      const value = control.value;\n      if (isNilOrBlank(value) || Number.isNaN(value)) {\n        return null;\n      }\n      // WARN: Convert value into integer, before applying modulo operator\n      const mod = Math.round(+value * multiplier) % multipliedPrecision;\n      if (mod !== 0) {\n        // DEBUG\n        //console.debug(`WARN Getting a ${value} with an invalid precision (expected precision is: ${precision})`);\n        return { precision: { precision } };\n      }\n      return null;\n    };\n  }\n\n  static validDate(control: UntypedFormControl): ValidationErrors | null {\n    const value = control.value;\n    const date = !value || isMoment(value) ? value : fromDateISOString(value);\n    if (date && (!date.isValid() || date.year() < 1900)) {\n      return {validDate: true};\n    }\n    return null;\n  }\n\n  static dateIsAfter(previousValue: Moment, errorParam: string, granularity?: unitOfTime.StartOf): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      const value = fromDateISOString(control.value);\n      if (isNotNil(value) && isNotNil(previousValue) && value.isSameOrBefore(previousValue, granularity)) {\n        // Return the error\n        return {dateIsAfter: {minDate: errorParam}};\n      }\n      return null;\n    };\n  }\n\n  static dateIsBefore(maxValue: Moment, errorParam: string, granularity?: unitOfTime.StartOf): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      const value = fromDateISOString(control.value);\n      if (isNotNil(value) && isNotNil(maxValue) && value.isSameOrAfter(maxValue, granularity)) {\n        // Return the error\n        return {dateIsBefore: {maxDate: errorParam}};\n      }\n      return null;\n    };\n  }\n\n  static dateRangeEnd(startDateFieldName: string, msg?: string): ValidatorFn {\n    const errorCode = msg ? 'msg': 'dateRange';\n    const error = msg ? {msg} : {dateRange: true};\n    return (control: AbstractControl): ValidationErrors | null => {\n      // Form group not created yet: skip\n      if (!control.parent) return null;\n\n      const startControl = control.parent.get(startDateFieldName);\n      if (!startControl) {\n        console.warn(`Cannot find brother control '${startDateFieldName}' in the parent form`);\n        return null;\n      }\n      const startDate = fromDateISOString(startControl.value);\n      const endDate = fromDateISOString(control.value);\n      // Error if value <= beforeDate\n      if (isNotNil(endDate) && isNotNil(startDate) && endDate.isSameOrBefore(startDate)) {\n        return error;\n      }\n      // OK: clear existing errors\n      SharedValidators.clearError(control, errorCode);\n      return null;\n    };\n  }\n\n  static dateRangeStart(endDateFieldName: string, msg?: string): ValidatorFn {\n    const errorCode = msg ? 'msg': 'dateRange';\n    const error = msg ? {msg} : {dateRange: true};\n    return (control: AbstractControl): ValidationErrors | null => {\n      // Form group not created yet: skip\n      if (!control.parent) return null;\n\n      const endDateControl = control.parent.get(endDateFieldName);\n      if (!endDateControl) {\n        console.warn(`Cannot find control '${endDateFieldName}' in the parent form`);\n        return null;\n      }\n      const endDate = fromDateISOString(endDateControl.value);\n      const startDate = fromDateISOString(control.value);\n      // Error if value <= beforeDate\n      if (isNotNil(startDate) && isNotNil(endDate) && startDate.isSameOrAfter(endDate)) {\n        return error;\n      }\n      // OK: clear existing errors\n      SharedValidators.clearError(control, errorCode);\n      return null;\n    };\n  }\n\n  static copyParentErrors(errorNames?: string[]): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      // Skip if control already has some errors\n      if (control.errors) return null;\n      // Skip if parent form group not created yet\n      if (!control.parent) return null;\n\n      // Form group not created yet\n      if (!control.parent) return null;\n\n      const errors = control.parent.errors;\n\n      // No errors, or copy all errors\n      if (!errors || isEmptyArray(errorNames)) return errors;\n\n      // Copy only expected errors\n      return Object.keys(errors).reduce((res, key) => {\n        if (errorNames.includes(key)) {\n          res[key] = errors[key];\n        }\n        return res;\n      }, {});\n    };\n  }\n\n  static clearError(control: AbstractControl, errorCode: string) {\n    if (control.hasError(errorCode)) {\n      const errors = control.errors;\n      if (errors && errors[errorCode]) {\n        // Only one error: reset errors\n        if (Object.getOwnPropertyNames(errors).length === 1) {\n          control.setErrors(null);\n        }\n        // Other errors exists: just remove this error\n        else {\n          delete errors[errorCode];\n          control.setErrors(errors);\n        }\n      }\n    }\n  }\n\n\n}\n\n// @dynamic\nexport class SharedFormGroupValidators {\n\n  static dateRange(startDateField: string, endDateField: string, msg?: string ): ValidatorFn {\n    const errorCode = isNotNilOrBlank(msg) ? 'msg' : 'dateRange';\n    const rangeError = msg ? {msg} : {dateRange: true};\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const startDate = fromDateISOString(group.get(startDateField).value);\n      const endField = group.get(endDateField);\n      const endDate = fromDateISOString(endField.value);\n      if (isNotNil(startDate) && isNotNil(endDate) && startDate.isAfter(endDate)) {\n        // Update end field\n        endField.markAsPending();\n        endField.setErrors({\n          ...endField.errors,\n          ...rangeError\n        });\n        // Return the error (should be apply to the parent form)\n        return rangeError;\n      }\n      // OK: remove the existing on the end field\n      SharedValidators.clearError(endField, errorCode);\n      return null;\n    };\n  }\n\n  static dateMaxDuration(startDateField: string, endDateField: string, maxDuration: number, durationUnit?: moment.unitOfTime.Diff): ValidatorFn {\n    const maxDurationError = {dateMaxDuration: true};\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const startDate = fromDateISOString(group.get(startDateField).value);\n      const endField = group.get(endDateField);\n      const endDate = fromDateISOString(endField.value);\n      if (isNotNil(startDate) && isNotNil(endDate) && Math.abs(startDate.diff(endDate, durationUnit)) > maxDuration) {\n        // Update end field\n        endField.markAsTouched({onlySelf: true});\n        endField.markAsPending();\n        endField.setErrors({\n          ...endField.errors,\n          ...maxDurationError\n        });\n        // Return the error (should be apply to the parent form)\n        return maxDurationError;\n      }\n      // OK: remove the existing on the end field\n      SharedValidators.clearError(endField, 'dateMaxDuration');\n      return null;\n    };\n  }\n\n  static dateMinDuration(startDateField: string, endDateField: string, minDuration: number, durationUnit?: moment.unitOfTime.Diff): ValidatorFn {\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const endField = group.get(endDateField);\n      const startDate = fromDateISOString(group.get(startDateField).value);\n      const endDate = fromDateISOString(endField.value);\n      if (isNotNil(startDate) && isNotNil(endDate) && Math.abs(startDate.diff(endDate, durationUnit)) < minDuration) {\n        // Update end field\n        const endFieldErrors: ValidationErrors = endField.errors || {};\n        endFieldErrors['dateMinDuration'] = true;\n        endField.setErrors(endFieldErrors);\n        endField.markAsTouched({onlySelf: true});\n        // Return the error (should be apply to the parent form)\n        return {dateMinDuration: true};\n      }\n      // OK: remove the existing on the end field\n      else {\n        SharedValidators.clearError(endField, 'dateMinDuration');\n      }\n      return null;\n    };\n  }\n\n  static requiredIf(fieldName: string, anotherFieldToCheck: string | AbstractControl): ValidatorFn {\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const control = group.get(fieldName);\n      const anotherControl = (anotherFieldToCheck instanceof AbstractControl) ? anotherFieldToCheck : group.get(anotherFieldToCheck);\n      if (!anotherControl) throw new Error('Unable to find field to check!');\n      if (isNilOrBlank(control.value) && isNotNilOrBlank(anotherControl.value)) {\n        const error = {required: true};\n        control.setErrors(error);\n        control.markAsTouched({onlySelf: true});\n        return error;\n      }\n      SharedValidators.clearError(control, 'required');\n      return null;\n    };\n  }\n\n  static requiredIfTrue(fieldName: string, anotherFieldToCheck: string | AbstractControl): ValidatorFn {\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const control = group.get(fieldName);\n      const anotherControl = (anotherFieldToCheck instanceof AbstractControl) ? anotherFieldToCheck : group.get(anotherFieldToCheck);\n      if (!anotherControl) throw new Error('Unable to find field to check!');\n      if (isNilOrBlank(control.value) && toBoolean(anotherControl.value, false)) {\n        const error = {required: true};\n        control.setErrors(error);\n        control.markAsTouched({onlySelf: true});\n        return error;\n      }\n      SharedValidators.clearError(control, 'required');\n      return null;\n    };\n  }\n\n  static requiredIfEmpty(fieldName: string, anotherFieldToCheck: string): ValidatorFn {\n    return (group: UntypedFormGroup): ValidationErrors | null => {\n      const control = group.get(fieldName);\n      if (isNilOrBlank(control.value) && isNilOrBlank(group.get(anotherFieldToCheck).value)) {\n        const error = {required: true};\n        control.setErrors(error);\n        control.markAsTouched({onlySelf: true});\n        return error;\n      }\n      SharedValidators.clearError(control, 'required');\n      return null;\n    };\n  }\n\n  static propagateIfDirty(fieldName: string, fieldNameToPropagate: string, valueToPropagate: any): ValidatorFn {\n    return (group: UntypedFormGroup): null => {\n      const control = group.get(fieldName);\n      const controlToPropagate = group.get(fieldNameToPropagate);\n      if (control.dirty && controlToPropagate.value !== valueToPropagate) {\n        controlToPropagate.setValue(valueToPropagate);\n      }\n      return null;\n    };\n  }\n\n  /**\n   * Same as compose, but keep only the first errors (instead of the union)\n   *\n   * @param validators\n   */\n  first(validators: (ValidatorFn | null | undefined)[]): ValidationErrors | null {\n    return (control) => validators\n      .filter(isNotNil)\n      .map(validator => validator(control))\n      .find(isNotNil) || null;\n  }\n}\n\n// @dynamic\nexport class SharedFormArrayValidators {\n\n  /**\n   * Validate uniqueness of an entity in a FormArray\n   *\n   * @param controlName the name of the control in FormArray\n   */\n  static uniqueEntity(controlName: string): ValidatorFn {\n    return (array: UntypedFormArray): ValidationErrors | null => {\n      const controls: AbstractControl[] = [];\n      if (array.length) {\n        // gather controls in array with valid entity\n        for (const control of array.controls) {\n          const fromGroup = control as UntypedFormGroup;\n          if (fromGroup.controls[controlName]) {\n            const value = fromGroup.controls[controlName].value;\n            if (!!value && !!value.id)\n              controls.push(fromGroup.controls[controlName]);\n          }\n        }\n        // get occurrences of entity by id\n        const occurrences = controls.reduce((acc, control) => {\n          const id = control.value.id;\n          if (acc[id]) acc[id]++;\n          else acc[id] = 1;\n          return acc;\n        }, {});\n        // get controls with value occurrences > 1\n        const error = {uniqueEntity: true};\n        let returnError = false;\n        controls.filter(control => occurrences[control.value.id] > 1)\n          .forEach(control => {\n            let errors: ValidationErrors = control.errors || {};\n            errors = {...errors, ...error};\n            control.setErrors(errors);\n            control.markAsTouched({onlySelf: true});\n            returnError = true;\n          });\n        if (returnError)\n          return error;\n      }\n      controls.forEach(control => SharedValidators.clearError(control, 'uniqueEntity'));\n      return null;\n    };\n  }\n\n  static requiredArrayMinLength(minLength?: number): ValidatorFn {\n    minLength = minLength || 1;\n    return (array: UntypedFormArray): ValidationErrors | null => {\n      if (!array || array.length < minLength) {\n        return {required: true};\n      }\n      return null;\n    };\n  }\n\n  /**\n   * Validate the sum of control values in an FormArray not overflow the max value\n   *\n   * @param controlName the name of the control in FormArray\n   * @param max the maximum value\n   */\n  static validSumMaxValue(controlName: string, max: number): ValidatorFn {\n    return (array: UntypedFormArray): ValidationErrors | null => {\n      const controls: AbstractControl[] = [];\n      if (array.length) {\n        for (const control of array.controls) {\n          const fromGroup = control as UntypedFormGroup;\n          if (fromGroup.controls[controlName] && isNotNilOrNaN(fromGroup.controls[controlName].value)) {\n            controls.push(fromGroup.controls[controlName]);\n          }\n        }\n        if (controls.reduce((sum, control) => sum + control.value, 0) > max) {\n          const error = {sumMaxValue: true};\n          controls.forEach(control => {\n            let errors: ValidationErrors = control.errors || {};\n            errors = {...errors, ...error};\n            control.setErrors(errors);\n            control.markAsTouched({onlySelf: true});\n          });\n          return error;\n        }\n      }\n      controls.forEach(control => SharedValidators.clearError(control, 'sumMaxValue'));\n      return null;\n    };\n  }\n\n}\n\nexport declare type ObservableValidatorFn = (control: AbstractControl) => Observable<ValidationErrors | null>;\nexport declare type PromiseValidatorFn = (control: AbstractControl) => Promise<ValidationErrors | null>;\n\n// @dynamic\nexport class SharedAsyncValidators {\n\n  private static DEBOUNCE_TIME_VALIDATOR_ID = 0;\n\n  /**\n   * Add a debounce time to a validator.\n   *\n   * @param form\n   * @param validatorFn\n   * @param opts Use opts.stopSubject to stop the validator, before end\n   */\n  static debounceTime(validatorFn: ValidatorFn | AsyncValidatorFn,\n                      opts?: {\n                        dispose?: Observable<any>;\n                        debounceTime?: number;\n                        markForCheck?: () => void;\n                        debug?: boolean;\n                      }): ObservableValidatorFn {\n\n    // DEBUG only\n    const debug = opts?.debug || false ;\n    const logPrefix = debug && `[debounceTime-validator] #${SharedAsyncValidators.DEBOUNCE_TIME_VALIDATOR_ID++} - `;\n    const debounceTime = toNumber(opts?.debounceTime, 250);\n\n    // DEBUG\n    if (debug) console.debug(logPrefix + `New validator with a debounceTime at ${debounceTime}ms`);\n\n    const $disposeSubject = new Subject<void>();\n    const disposeEvent$ = opts?.dispose\n      ? merge($disposeSubject, opts?.dispose)\n      : $disposeSubject;\n\n    // DEBUG\n    if (debug && opts?.dispose) {\n      opts?.dispose.pipe(first()).subscribe(() => {\n        console.debug(logPrefix + 'Stopping');\n      });\n    }\n\n    return (control) => {\n      if (debug) console.debug(logPrefix + 'Form ask validation...');\n\n      // Stop previous observables\n      $disposeSubject.next();\n      let now: number;\n\n      // Add a delay before execution\n      return timer(debounceTime)\n        .pipe(\n          // DEBUG\n          tap(_ => {\n            if (debug) {\n              console.debug(logPrefix + 'Executing...');\n              now = Date.now();\n            }\n          }),\n          switchMap((_) => {\n            // Call the validator\n            const res = validatorFn(control);\n            // Make sure to return an Observable\n            if (isObservable(res)) return res;\n            if (res instanceof Promise) return from(res);\n            return of(res);\n          }),\n          // DEBUG\n          tap(res => debug && console.debug(logPrefix + `Finished in ${Date.now() - now}ms (${res ? 'with errors' : 'no error'})`, res)),\n          catchError(error => {\n            console.error('[debounceTime-validator] Error while executing validator. Stopping job', error);\n            $disposeSubject.next();\n            throw error;\n          }),\n          // Refresh UI, after a successful execution\n          tap(() => opts?.markForCheck && opts?.markForCheck()),\n          // Make sure to stop, because of the switchMap\n          takeUntil(disposeEvent$)\n        );\n    };\n  }\n\n  /**\n   * Add an async validator, that can be disposed by the returned subscription\n   *\n   * @param form\n   * @param validatorFn the validator or job to execute\n   * @param opts\n   */\n  static registerAsyncValidator(form: AbstractControl,\n                                validatorFn: ValidatorFn | AsyncValidatorFn,\n                                opts?: {\n                                  debounceTime?: number;\n                                  markForCheck?: () => void;\n                                  debug?: boolean;\n                                }): Subscription {\n    if (form.asyncValidator) throw Error('Form already have an async validator. Cannot configure job');\n\n    const debounceTime = toNumber(opts?.debounceTime, 250);\n    const $dispose = new Subject<void>();\n\n    const asyncValidatorFn = SharedAsyncValidators.debounceTime(validatorFn, {...opts, debounceTime, dispose: $dispose });\n    form.setAsyncValidators(asyncValidatorFn);\n\n    const subscription = new Subscription();\n\n    // When unsubscribing, remove async validator\n    subscription.add(() => {\n      // Clear added validator. Must be done NOW (without delay) because generally a new Job is given just after\n      form.clearAsyncValidators();\n\n      // Stop the job, with a delay to let the last execution finished\n      setTimeout(() => {\n        $dispose.next();\n        $dispose.unsubscribe();\n      }, debounceTime);\n    });\n\n    return subscription;\n  }\n}\n"]}