@ng-formworks/core 17.2.7 → 17.4.0

package/esm2022/lib/shared/json.validators.mjs

@@ -0,0 +1,884 @@
+import isEqual from 'lodash/isEqual';
+import { _executeAsyncValidators, _executeValidators, _mergeErrors, _mergeObjects, getType, hasValue, isArray, isBoolean, isDefined, isEmpty, isNumber, isString, isType, toJavaScriptType, toObservable, xor } from './validator.functions';
+import { forEachCopy } from './utility.functions';
+import { forkJoin } from 'rxjs';
+import { jsonSchemaFormatTests } from './format-regex.constants';
+import { map } from 'rxjs/operators';
+/**
+ * 'JsonValidators' class
+ *
+ * Provides an extended set of validators to be used by form controls,
+ * compatible with standard JSON Schema validation options.
+ * http://json-schema.org/latest/json-schema-validation.html
+ *
+ * Note: This library is designed as a drop-in replacement for the Angular
+ * Validators library, and except for one small breaking change to the 'pattern'
+ * validator (described below) it can even be imported as a substitute, like so:
+ *
+ *   import { JsonValidators as Validators } from 'json-validators';
+ *
+ * and it should work with existing code as a complete replacement.
+ *
+ * The one exception is the 'pattern' validator, which has been changed to
+ * matche partial values by default (the standard 'pattern' validator wrapped
+ * all patterns in '^' and '$', forcing them to always match an entire value).
+ * However, the old behavior can be restored by simply adding '^' and '$'
+ * around your patterns, or by passing an optional second parameter of TRUE.
+ * This change is to make the 'pattern' validator match the behavior of a
+ * JSON Schema pattern, which allows partial matches, rather than the behavior
+ * of an HTML input control pattern, which does not.
+ *
+ * This library replaces Angular's validators and combination functions
+ * with the following validators and transformation functions:
+ *
+ * Validators:
+ *   For all formControls:     required (*), type, enum, const
+ *   For text formControls:    minLength (*), maxLength (*), pattern (*), format
+ *   For numeric formControls: maximum, exclusiveMaximum,
+ *                             minimum, exclusiveMinimum, multipleOf
+ *   For formGroup objects:    minProperties, maxProperties, dependencies
+ *   For formArray arrays:     minItems, maxItems, uniqueItems, contains
+ *   Not used by JSON Schema:  min (*), max (*), requiredTrue (*), email (*)
+ * (Validators originally included with Angular are maked with (*).)
+ *
+ * NOTE / TODO: The dependencies validator is not complete.
+ * NOTE / TODO: The contains validator is not complete.
+ *
+ * Validators not used by JSON Schema (but included for compatibility)
+ * and their JSON Schema equivalents:
+ *
+ *   Angular validator | JSON Schema equivalent
+ *   ------------------|-----------------------
+ *     min(number)     |   minimum(number)
+ *     max(number)     |   maximum(number)
+ *     requiredTrue()  |   const(true)
+ *     email()         |   format('email')
+ *
+ * Validator transformation functions:
+ *   composeAnyOf, composeOneOf, composeAllOf, composeNot
+ * (Angular's original combination funciton, 'compose', is also included for
+ * backward compatibility, though it is functionally equivalent to composeAllOf,
+ * asside from its more generic error message.)
+ *
+ * All validators have also been extended to accept an optional second argument
+ * which, if passed a TRUE value, causes the validator to perform the opposite
+ * of its original finction. (This is used internally to enable 'not' and
+ * 'composeOneOf' to function and return useful error messages.)
+ *
+ * The 'required' validator has also been overloaded so that if called with
+ * a boolean parameter (or no parameters) it returns the original validator
+ * function (rather than executing it). However, if it is called with an
+ * AbstractControl parameter (as was previously required), it behaves
+ * exactly as before.
+ *
+ * This enables all validators (including 'required') to be constructed in
+ * exactly the same way, so they can be automatically applied using the
+ * equivalent key names and values taken directly from a JSON Schema.
+ *
+ * This source code is partially derived from Angular,
+ * which is Copyright (c) 2014-2017 Google, Inc.
+ * Use of this source code is therefore governed by the same MIT-style license
+ * that can be found in the LICENSE file at https://angular.io/license
+ *
+ * Original Angular Validators:
+ * https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts
+ */
+export class JsonValidators {
+    static required(input) {
+        if (input === undefined) {
+            input = true;
+        }
+        switch (input) {
+            case true: // Return required function (do not execute it yet)
+                return (control, invert = false) => {
+                    if (invert) {
+                        return null;
+                    } // if not required, always return valid
+                    return hasValue(control.value) ? null : { 'required': true };
+                };
+            case false: // Do nothing (if field is not required, it is always valid)
+                return JsonValidators.nullValidator;
+            default: // Execute required function
+                return hasValue(input.value) ? null : { 'required': true };
+        }
+    }
+    /**
+     * 'type' validator
+     *
+     * Requires a control to only accept values of a specified type,
+     * or one of an array of types.
+     *
+     * Note: SchemaPrimitiveType = 'string'|'number'|'integer'|'boolean'|'null'
+     *
+     * // {SchemaPrimitiveType|SchemaPrimitiveType[]} type - type(s) to accept
+     * // {IValidatorFn}
+     */
+    static type(requiredType) {
+        if (!hasValue(requiredType)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = isArray(requiredType) ?
+                requiredType.some(type => isType(currentValue, type)) :
+                isType(currentValue, requiredType);
+            return xor(isValid, invert) ?
+                null : { 'type': { requiredType, currentValue } };
+        };
+    }
+    /**
+     * 'enum' validator
+     *
+     * Requires a control to have a value from an enumerated list of values.
+     *
+     * Converts types as needed to allow string inputs to still correctly
+     * match number, boolean, and null enum values.
+     *
+     * // {any[]} allowedValues - array of acceptable values
+     * // {IValidatorFn}
+     */
+    static enum(allowedValues) {
+        if (!isArray(allowedValues)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isEqualVal = (enumValue, inputValue) => enumValue === inputValue ||
+                (isNumber(enumValue) && +inputValue === +enumValue) ||
+                (isBoolean(enumValue, 'strict') &&
+                    toJavaScriptType(inputValue, 'boolean') === enumValue) ||
+                (enumValue === null && !hasValue(inputValue)) ||
+                isEqual(enumValue, inputValue);
+            const isValid = isArray(currentValue) ?
+                currentValue.every(inputValue => allowedValues.some(enumValue => isEqualVal(enumValue, inputValue))) :
+                allowedValues.some(enumValue => isEqualVal(enumValue, currentValue));
+            return xor(isValid, invert) ?
+                null : { 'enum': { allowedValues, currentValue } };
+        };
+    }
+    /**
+     * 'const' validator
+     *
+     * Requires a control to have a specific value.
+     *
+     * Converts types as needed to allow string inputs to still correctly
+     * match number, boolean, and null values.
+     *
+     * TODO: modify to work with objects
+     *
+     * // {any[]} requiredValue - required value
+     * // {IValidatorFn}
+     */
+    static const(requiredValue) {
+        if (!hasValue(requiredValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isEqualVal = (constValue, inputValue) => constValue === inputValue ||
+                isNumber(constValue) && +inputValue === +constValue ||
+                isBoolean(constValue, 'strict') &&
+                    toJavaScriptType(inputValue, 'boolean') === constValue ||
+                constValue === null && !hasValue(inputValue);
+            const isValid = isEqualVal(requiredValue, currentValue);
+            return xor(isValid, invert) ?
+                null : { 'const': { requiredValue, currentValue } };
+        };
+    }
+    /**
+     * 'minLength' validator
+     *
+     * Requires a control's text value to be greater than a specified length.
+     *
+     * // {number} minimumLength - minimum allowed string length
+     * // {boolean = false} invert - instead return error object only if valid
+     * // {IValidatorFn}
+     */
+    static minLength(minimumLength) {
+        if (!hasValue(minimumLength)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentLength = isString(control.value) ? control.value.length : 0;
+            const isValid = currentLength >= minimumLength;
+            return xor(isValid, invert) ?
+                null : { 'minLength': { minimumLength, currentLength } };
+        };
+    }
+    /**
+     * 'maxLength' validator
+     *
+     * Requires a control's text value to be less than a specified length.
+     *
+     * // {number} maximumLength - maximum allowed string length
+     * // {boolean = false} invert - instead return error object only if valid
+     * // {IValidatorFn}
+     */
+    static maxLength(maximumLength) {
+        if (!hasValue(maximumLength)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            const currentLength = isString(control.value) ? control.value.length : 0;
+            const isValid = currentLength <= maximumLength;
+            return xor(isValid, invert) ?
+                null : { 'maxLength': { maximumLength, currentLength } };
+        };
+    }
+    /**
+     * 'pattern' validator
+     *
+     * Note: NOT the same as Angular's default pattern validator.
+     *
+     * Requires a control's value to match a specified regular expression pattern.
+     *
+     * This validator changes the behavior of default pattern validator
+     * by replacing RegExp(`^${pattern}$`) with RegExp(`${pattern}`),
+     * which allows for partial matches.
+     *
+     * To return to the default funcitonality, and match the entire string,
+     * pass TRUE as the optional second parameter.
+     *
+     * // {string} pattern - regular expression pattern
+     * // {boolean = false} wholeString - match whole value string?
+     * // {IValidatorFn}
+     */
+    static pattern(pattern, wholeString = false) {
+        if (!hasValue(pattern)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            let regex;
+            let requiredPattern;
+            if (typeof pattern === 'string') {
+                requiredPattern = (wholeString) ? `^${pattern}$` : pattern;
+                regex = new RegExp(requiredPattern);
+            }
+            else {
+                requiredPattern = pattern.toString();
+                regex = pattern;
+            }
+            const currentValue = control.value;
+            const isValid = isString(currentValue) ? regex.test(currentValue) : false;
+            return xor(isValid, invert) ?
+                null : { 'pattern': { requiredPattern, currentValue } };
+        };
+    }
+    /**
+     * 'format' validator
+     *
+     * Requires a control to have a value of a certain format.
+     *
+     * This validator currently checks the following formsts:
+     *   date, time, date-time, email, hostname, ipv4, ipv6,
+     *   uri, uri-reference, uri-template, url, uuid, color,
+     *   json-pointer, relative-json-pointer, regex
+     *
+     * Fast format regular expressions copied from AJV:
+     * https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js
+     *
+     * // {JsonSchemaFormatNames} requiredFormat - format to check
+     * // {IValidatorFn}
+     */
+    static format(requiredFormat) {
+        if (!hasValue(requiredFormat)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            let isValid;
+            const currentValue = control.value;
+            if (isString(currentValue)) {
+                const formatTest = jsonSchemaFormatTests[requiredFormat];
+                if (typeof formatTest === 'object') {
+                    isValid = formatTest.test(currentValue);
+                }
+                else if (typeof formatTest === 'function') {
+                    isValid = formatTest(currentValue);
+                }
+                else {
+                    console.error(`format validator error: "${requiredFormat}" is not a recognized format.`);
+                    isValid = true;
+                }
+            }
+            else {
+                // Allow JavaScript Date objects
+                isValid = ['date', 'time', 'date-time'].includes(requiredFormat) &&
+                    Object.prototype.toString.call(currentValue) === '[object Date]';
+            }
+            return xor(isValid, invert) ?
+                null : { 'format': { requiredFormat, currentValue } };
+        };
+    }
+    /**
+     * 'minimum' validator
+     *
+     * Requires a control's numeric value to be greater than or equal to
+     * a minimum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a minimum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} minimum - minimum allowed value
+     * // {IValidatorFn}
+     */
+    static minimum(minimumValue) {
+        if (!hasValue(minimumValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = !isNumber(currentValue) || currentValue >= minimumValue;
+            return xor(isValid, invert) ?
+                null : { 'minimum': { minimumValue, currentValue } };
+        };
+    }
+    /**
+     * 'exclusiveMinimum' validator
+     *
+     * Requires a control's numeric value to be less than a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} exclusiveMinimumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static exclusiveMinimum(exclusiveMinimumValue) {
+        if (!hasValue(exclusiveMinimumValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = !isNumber(currentValue) || +currentValue < exclusiveMinimumValue;
+            return xor(isValid, invert) ?
+                null : { 'exclusiveMinimum': { exclusiveMinimumValue, currentValue } };
+        };
+    }
+    /**
+     * 'maximum' validator
+     *
+     * Requires a control's numeric value to be less than or equal to
+     * a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} maximumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static maximum(maximumValue) {
+        if (!hasValue(maximumValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = !isNumber(currentValue) || +currentValue <= maximumValue;
+            return xor(isValid, invert) ?
+                null : { 'maximum': { maximumValue, currentValue } };
+        };
+    }
+    /**
+     * 'exclusiveMaximum' validator
+     *
+     * Requires a control's numeric value to be less than a maximum amount.
+     *
+     * Any non-numeric value is also valid (according to the HTML forms spec,
+     * a non-numeric value doesn't have a maximum).
+     * https://www.w3.org/TR/html5/forms.html#attr-input-max
+     *
+     * // {number} exclusiveMaximumValue - maximum allowed value
+     * // {IValidatorFn}
+     */
+    static exclusiveMaximum(exclusiveMaximumValue) {
+        if (!hasValue(exclusiveMaximumValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = !isNumber(currentValue) || +currentValue < exclusiveMaximumValue;
+            return xor(isValid, invert) ?
+                null : { 'exclusiveMaximum': { exclusiveMaximumValue, currentValue } };
+        };
+    }
+    /**
+     * 'multipleOf' validator
+     *
+     * Requires a control to have a numeric value that is a multiple
+     * of a specified number.
+     *
+     * // {number} multipleOfValue - number value must be a multiple of
+     * // {IValidatorFn}
+     */
+    static multipleOf(multipleOfValue) {
+        if (!hasValue(multipleOfValue)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentValue = control.value;
+            const isValid = isNumber(currentValue) &&
+                currentValue % multipleOfValue === 0;
+            return xor(isValid, invert) ?
+                null : { 'multipleOf': { multipleOfValue, currentValue } };
+        };
+    }
+    /**
+     * 'minProperties' validator
+     *
+     * Requires a form group to have a minimum number of properties (i.e. have
+     * values entered in a minimum number of controls within the group).
+     *
+     * // {number} minimumProperties - minimum number of properties allowed
+     * // {IValidatorFn}
+     */
+    static minProperties(minimumProperties) {
+        if (!hasValue(minimumProperties)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentProperties = Object.keys(control.value).length || 0;
+            const isValid = currentProperties >= minimumProperties;
+            return xor(isValid, invert) ?
+                null : { 'minProperties': { minimumProperties, currentProperties } };
+        };
+    }
+    /**
+     * 'maxProperties' validator
+     *
+     * Requires a form group to have a maximum number of properties (i.e. have
+     * values entered in a maximum number of controls within the group).
+     *
+     * Note: Has no effect if the form group does not contain more than the
+     * maximum number of controls.
+     *
+     * // {number} maximumProperties - maximum number of properties allowed
+     * // {IValidatorFn}
+     */
+    static maxProperties(maximumProperties) {
+        if (!hasValue(maximumProperties)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            const currentProperties = Object.keys(control.value).length || 0;
+            const isValid = currentProperties <= maximumProperties;
+            return xor(isValid, invert) ?
+                null : { 'maxProperties': { maximumProperties, currentProperties } };
+        };
+    }
+    /**
+     * 'dependencies' validator
+     *
+     * Requires the controls in a form group to meet additional validation
+     * criteria, depending on the values of other controls in the group.
+     *
+     * Examples:
+     * https://spacetelescope.github.io/understanding-json-schema/reference/object.html#dependencies
+     *
+     * // {any} dependencies - required dependencies
+     * // {IValidatorFn}
+     */
+    static dependencies(dependencies) {
+        if (getType(dependencies) !== 'object' || isEmpty(dependencies)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const allErrors = _mergeObjects(forEachCopy(dependencies, (value, requiringField) => {
+                if (!hasValue(control.value[requiringField])) {
+                    return null;
+                }
+                let requiringFieldErrors = {};
+                let requiredFields;
+                let properties = {};
+                if (getType(dependencies[requiringField]) === 'array') {
+                    requiredFields = dependencies[requiringField];
+                }
+                else if (getType(dependencies[requiringField]) === 'object') {
+                    requiredFields = dependencies[requiringField]['required'] || [];
+                    properties = dependencies[requiringField]['properties'] || {};
+                }
+                // Validate property dependencies
+                for (const requiredField of requiredFields) {
+                    if (xor(!hasValue(control.value[requiredField]), invert)) {
+                        requiringFieldErrors[requiredField] = { 'required': true };
+                    }
+                }
+                // Validate schema dependencies
+                requiringFieldErrors = _mergeObjects(requiringFieldErrors, forEachCopy(properties, (requirements, requiredField) => {
+                    const requiredFieldErrors = _mergeObjects(forEachCopy(requirements, (requirement, parameter) => {
+                        let validator = null;
+                        if (requirement === 'maximum' || requirement === 'minimum') {
+                            const exclusive = !!requirements['exclusiveM' + requirement.slice(1)];
+                            validator = JsonValidators[requirement](parameter, exclusive);
+                        }
+                        else if (typeof JsonValidators[requirement] === 'function') {
+                            validator = JsonValidators[requirement](parameter);
+                        }
+                        return !isDefined(validator) ?
+                            null : validator(control.value[requiredField]);
+                    }));
+                    return isEmpty(requiredFieldErrors) ?
+                        null : { [requiredField]: requiredFieldErrors };
+                }));
+                return isEmpty(requiringFieldErrors) ?
+                    null : { [requiringField]: requiringFieldErrors };
+            }));
+            return isEmpty(allErrors) ? null : allErrors;
+        };
+    }
+    /**
+     * 'minItems' validator
+     *
+     * Requires a form array to have a minimum number of values.
+     *
+     * // {number} minimumItems - minimum number of items allowed
+     * // {IValidatorFn}
+     */
+    static minItems(minimumItems) {
+        if (!hasValue(minimumItems)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const currentItems = isArray(control.value) ? control.value.length : 0;
+            const isValid = currentItems >= minimumItems;
+            return xor(isValid, invert) ?
+                null : { 'minItems': { minimumItems, currentItems } };
+        };
+    }
+    /**
+     * 'maxItems' validator
+     *
+     * Requires a form array to have a maximum number of values.
+     *
+     * // {number} maximumItems - maximum number of items allowed
+     * // {IValidatorFn}
+     */
+    static maxItems(maximumItems) {
+        if (!hasValue(maximumItems)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            const currentItems = isArray(control.value) ? control.value.length : 0;
+            const isValid = currentItems <= maximumItems;
+            return xor(isValid, invert) ?
+                null : { 'maxItems': { maximumItems, currentItems } };
+        };
+    }
+    /**
+     * 'uniqueItems' validator
+     *
+     * Requires values in a form array to be unique.
+     *
+     * // {boolean = true} unique? - true to validate, false to disable
+     * // {IValidatorFn}
+     */
+    static uniqueItems(unique = true) {
+        if (!unique) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const sorted = control.value.slice().sort();
+            const duplicateItems = [];
+            for (let i = 1; i < sorted.length; i++) {
+                if (sorted[i - 1] === sorted[i] && duplicateItems.includes(sorted[i])) {
+                    duplicateItems.push(sorted[i]);
+                }
+            }
+            const isValid = !duplicateItems.length;
+            return xor(isValid, invert) ?
+                null : { 'uniqueItems': { duplicateItems } };
+        };
+    }
+    /**
+     * 'contains' validator
+     *
+     * TODO: Complete this validator
+     *
+     * Requires values in a form array to be unique.
+     *
+     * // {boolean = true} unique? - true to validate, false to disable
+     * // {IValidatorFn}
+     */
+    static contains(requiredItem = true) {
+        if (!requiredItem) {
+            return JsonValidators.nullValidator;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value) || !isArray(control.value)) {
+                return null;
+            }
+            const currentItems = control.value;
+            // const isValid = currentItems.some(item =>
+            //
+            // );
+            const isValid = true;
+            return xor(isValid, invert) ?
+                null : { 'contains': { requiredItem, currentItems } };
+        };
+    }
+    /**
+     * No-op validator. Included for backward compatibility.
+     */
+    static nullValidator(control) {
+        return null;
+    }
+    /**
+     * Validator transformation functions:
+     * composeAnyOf, composeOneOf, composeAllOf, composeNot,
+     * compose, composeAsync
+     *
+     * TODO: Add composeAnyOfAsync, composeOneOfAsync,
+     *           composeAllOfAsync, composeNotAsync
+     */
+    /**
+     * 'composeAnyOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid if any one or more of the submitted validators are
+     * valid. If every validator is invalid, it returns combined errors from
+     * all validators.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeAnyOf(validators) {
+        if (!validators) {
+            return null;
+        }
+        const presentValidators = validators.filter(isDefined);
+        if (presentValidators.length === 0) {
+            return null;
+        }
+        return (control, invert = false) => {
+            const arrayOfErrors = _executeValidators(control, presentValidators, invert).filter(isDefined);
+            const isValid = validators.length > arrayOfErrors.length;
+            return xor(isValid, invert) ?
+                null : _mergeObjects(...arrayOfErrors, { 'anyOf': !invert });
+        };
+    }
+    /**
+     * 'composeOneOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid only if exactly one of the submitted validators
+     * is valid. Otherwise returns combined information from all validators,
+     * both valid and invalid.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeOneOf(validators) {
+        if (!validators) {
+            return null;
+        }
+        const presentValidators = validators.filter(isDefined);
+        if (presentValidators.length === 0) {
+            return null;
+        }
+        return (control, invert = false) => {
+            const arrayOfErrors = _executeValidators(control, presentValidators);
+            const validControls = validators.length - arrayOfErrors.filter(isDefined).length;
+            const isValid = validControls === 1;
+            if (xor(isValid, invert)) {
+                return null;
+            }
+            const arrayOfValids = _executeValidators(control, presentValidators, invert);
+            return _mergeObjects(...arrayOfErrors, ...arrayOfValids, { 'oneOf': !invert });
+        };
+    }
+    /**
+     * 'composeAllOf' validator combination function
+     *
+     * Accepts an array of validators and returns a single validator that
+     * evaluates to valid only if all the submitted validators are individually
+     * valid. Otherwise it returns combined errors from all invalid validators.
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static composeAllOf(validators) {
+        if (!validators) {
+            return null;
+        }
+        const presentValidators = validators.filter(isDefined);
+        if (presentValidators.length === 0) {
+            return null;
+        }
+        return (control, invert = false) => {
+            const combinedErrors = _mergeErrors(_executeValidators(control, presentValidators, invert));
+            const isValid = combinedErrors === null;
+            return (xor(isValid, invert)) ?
+                null : _mergeObjects(combinedErrors, { 'allOf': !invert });
+        };
+    }
+    /**
+     * 'composeNot' validator inversion function
+     *
+     * Accepts a single validator function and inverts its result.
+     * Returns valid if the submitted validator is invalid, and
+     * returns invalid if the submitted validator is valid.
+     * (Note: this function can itself be inverted
+     *   - e.g. composeNot(composeNot(validator)) -
+     *   but this can be confusing and is therefore not recommended.)
+     *
+     * // {IValidatorFn[]} validators - validator(s) to invert
+     * // {IValidatorFn} - new validator function that returns opposite result
+     */
+    static composeNot(validator) {
+        if (!validator) {
+            return null;
+        }
+        return (control, invert = false) => {
+            if (isEmpty(control.value)) {
+                return null;
+            }
+            const error = validator(control, !invert);
+            const isValid = error === null;
+            return (xor(isValid, invert)) ?
+                null : _mergeObjects(error, { 'not': !invert });
+        };
+    }
+    /**
+     * 'compose' validator combination function
+     *
+     * // {IValidatorFn[]} validators - array of validators to combine
+     * // {IValidatorFn} - single combined validator function
+     */
+    static compose(validators) {
+        if (!validators) {
+            return null;
+        }
+        const presentValidators = validators.filter(isDefined);
+        if (presentValidators.length === 0) {
+            return null;
+        }
+        return (control, invert = false) => _mergeErrors(_executeValidators(control, presentValidators, invert));
+    }
+    /**
+     * 'composeAsync' async validator combination function
+     *
+     * // {AsyncIValidatorFn[]} async validators - array of async validators
+     * // {AsyncIValidatorFn} - single combined async validator function
+     */
+    static composeAsync(validators) {
+        if (!validators) {
+            return null;
+        }
+        const presentValidators = validators.filter(isDefined);
+        if (presentValidators.length === 0) {
+            return null;
+        }
+        return (control) => {
+            const observables = _executeAsyncValidators(control, presentValidators).map(toObservable);
+            return map.call(forkJoin(observables), _mergeErrors);
+        };
+    }
+    // Additional angular validators (not used by Angualr JSON Schema Form)
+    // From https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts
+    /**
+     * Validator that requires controls to have a value greater than a number.
+     */
+    static min(min) {
+        if (!hasValue(min)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control) => {
+            // don't validate empty values to allow optional controls
+            if (isEmpty(control.value) || isEmpty(min)) {
+                return null;
+            }
+            const value = parseFloat(control.value);
+            const actual = control.value;
+            // Controls with NaN values after parsing should be treated as not having a
+            // minimum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min
+            return isNaN(value) || value >= min ? null : { 'min': { min, actual } };
+        };
+    }
+    /**
+     * Validator that requires controls to have a value less than a number.
+     */
+    static max(max) {
+        if (!hasValue(max)) {
+            return JsonValidators.nullValidator;
+        }
+        return (control) => {
+            // don't validate empty values to allow optional controls
+            if (isEmpty(control.value) || isEmpty(max)) {
+                return null;
+            }
+            const value = parseFloat(control.value);
+            const actual = control.value;
+            // Controls with NaN values after parsing should be treated as not having a
+            // maximum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-max
+            return isNaN(value) || value <= max ? null : { 'max': { max, actual } };
+        };
+    }
+    /**
+     * Validator that requires control value to be true.
+     */
+    static requiredTrue(control) {
+        if (!control) {
+            return JsonValidators.nullValidator;
+        }
+        return control.value === true ? null : { 'required': true };
+    }
+    /**
+     * Validator that performs email validation.
+     */
+    static email(control) {
+        if (!control) {
+            return JsonValidators.nullValidator;
+        }
+        const EMAIL_REGEXP = 
+        // tslint:disable-next-line:max-line-length
+        /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+        return EMAIL_REGEXP.test(control.value) ? null : { 'email': true };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json.validators.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/json.validators.ts"],"names":[],"mappings":"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","sourcesContent":["import isEqual from 'lodash/isEqual';\r\nimport {\r\n  _executeAsyncValidators,\r\n  _executeValidators,\r\n  _mergeErrors,\r\n  _mergeObjects,\r\n  AsyncIValidatorFn,\r\n  getType,\r\n  hasValue,\r\n  isArray,\r\n  isBoolean,\r\n  isDefined,\r\n  isEmpty,\r\n  isNumber,\r\n  isString,\r\n  isType,\r\n  IValidatorFn,\r\n  SchemaPrimitiveType,\r\n  toJavaScriptType,\r\n  toObservable,\r\n  xor\r\n  } from './validator.functions';\r\nimport { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';\r\nimport { forEachCopy } from './utility.functions';\r\nimport { forkJoin } from 'rxjs';\r\nimport { JsonSchemaFormatNames, jsonSchemaFormatTests } from './format-regex.constants';\r\nimport { map } from 'rxjs/operators';\r\n\r\n\r\n\r\n/**\r\n * 'JsonValidators' class\r\n *\r\n * Provides an extended set of validators to be used by form controls,\r\n * compatible with standard JSON Schema validation options.\r\n * http://json-schema.org/latest/json-schema-validation.html\r\n *\r\n * Note: This library is designed as a drop-in replacement for the Angular\r\n * Validators library, and except for one small breaking change to the 'pattern'\r\n * validator (described below) it can even be imported as a substitute, like so:\r\n *\r\n *   import { JsonValidators as Validators } from 'json-validators';\r\n *\r\n * and it should work with existing code as a complete replacement.\r\n *\r\n * The one exception is the 'pattern' validator, which has been changed to\r\n * matche partial values by default (the standard 'pattern' validator wrapped\r\n * all patterns in '^' and '$', forcing them to always match an entire value).\r\n * However, the old behavior can be restored by simply adding '^' and '$'\r\n * around your patterns, or by passing an optional second parameter of TRUE.\r\n * This change is to make the 'pattern' validator match the behavior of a\r\n * JSON Schema pattern, which allows partial matches, rather than the behavior\r\n * of an HTML input control pattern, which does not.\r\n *\r\n * This library replaces Angular's validators and combination functions\r\n * with the following validators and transformation functions:\r\n *\r\n * Validators:\r\n *   For all formControls:     required (*), type, enum, const\r\n *   For text formControls:    minLength (*), maxLength (*), pattern (*), format\r\n *   For numeric formControls: maximum, exclusiveMaximum,\r\n *                             minimum, exclusiveMinimum, multipleOf\r\n *   For formGroup objects:    minProperties, maxProperties, dependencies\r\n *   For formArray arrays:     minItems, maxItems, uniqueItems, contains\r\n *   Not used by JSON Schema:  min (*), max (*), requiredTrue (*), email (*)\r\n * (Validators originally included with Angular are maked with (*).)\r\n *\r\n * NOTE / TODO: The dependencies validator is not complete.\r\n * NOTE / TODO: The contains validator is not complete.\r\n *\r\n * Validators not used by JSON Schema (but included for compatibility)\r\n * and their JSON Schema equivalents:\r\n *\r\n *   Angular validator | JSON Schema equivalent\r\n *   ------------------|-----------------------\r\n *     min(number)     |   minimum(number)\r\n *     max(number)     |   maximum(number)\r\n *     requiredTrue()  |   const(true)\r\n *     email()         |   format('email')\r\n *\r\n * Validator transformation functions:\r\n *   composeAnyOf, composeOneOf, composeAllOf, composeNot\r\n * (Angular's original combination funciton, 'compose', is also included for\r\n * backward compatibility, though it is functionally equivalent to composeAllOf,\r\n * asside from its more generic error message.)\r\n *\r\n * All validators have also been extended to accept an optional second argument\r\n * which, if passed a TRUE value, causes the validator to perform the opposite\r\n * of its original finction. (This is used internally to enable 'not' and\r\n * 'composeOneOf' to function and return useful error messages.)\r\n *\r\n * The 'required' validator has also been overloaded so that if called with\r\n * a boolean parameter (or no parameters) it returns the original validator\r\n * function (rather than executing it). However, if it is called with an\r\n * AbstractControl parameter (as was previously required), it behaves\r\n * exactly as before.\r\n *\r\n * This enables all validators (including 'required') to be constructed in\r\n * exactly the same way, so they can be automatically applied using the\r\n * equivalent key names and values taken directly from a JSON Schema.\r\n *\r\n * This source code is partially derived from Angular,\r\n * which is Copyright (c) 2014-2017 Google, Inc.\r\n * Use of this source code is therefore governed by the same MIT-style license\r\n * that can be found in the LICENSE file at https://angular.io/license\r\n *\r\n * Original Angular Validators:\r\n * https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts\r\n */\r\nexport class JsonValidators {\r\n\r\n  /**\r\n   * Validator functions:\r\n   *\r\n   * For all formControls:     required, type, enum, const\r\n   * For text formControls:    minLength, maxLength, pattern, format\r\n   * For numeric formControls: maximum, exclusiveMaximum,\r\n   *                           minimum, exclusiveMinimum, multipleOf\r\n   * For formGroup objects:    minProperties, maxProperties, dependencies\r\n   * For formArray arrays:     minItems, maxItems, uniqueItems, contains\r\n   *\r\n   * TODO: finish dependencies validator\r\n   */\r\n\r\n  /**\r\n   * 'required' validator\r\n   *\r\n   * This validator is overloaded, compared to the default required validator.\r\n   * If called with no parameters, or TRUE, this validator returns the\r\n   * 'required' validator function (rather than executing it). This matches\r\n   * the behavior of all other validators in this library.\r\n   *\r\n   * If this validator is called with an AbstractControl parameter\r\n   * (as was previously required) it behaves the same as Angular's default\r\n   * required validator, and returns an error if the control is empty.\r\n   *\r\n   * Old behavior: (if input type = AbstractControl)\r\n   * // {AbstractControl} control - required control\r\n   * // {{[key: string]: boolean}} - returns error message if no input\r\n   *\r\n   * New behavior: (if no input, or input type = boolean)\r\n   * // {boolean = true} required? - true to validate, false to disable\r\n   * // {IValidatorFn} - returns the 'required' validator function itself\r\n   */\r\n  static required(input: AbstractControl): ValidationErrors|null;\r\n  static required(input?: boolean): IValidatorFn;\r\n\r\n  static required(input?: AbstractControl|boolean): ValidationErrors|null|IValidatorFn {\r\n    if (input === undefined) { input = true; }\r\n    switch (input) {\r\n      case true: // Return required function (do not execute it yet)\r\n        return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n          if (invert) { return null; } // if not required, always return valid\r\n          return hasValue(control.value) ? null : { 'required': true };\r\n        };\r\n      case false: // Do nothing (if field is not required, it is always valid)\r\n        return JsonValidators.nullValidator;\r\n      default: // Execute required function\r\n        return hasValue((<AbstractControl>input).value) ? null : { 'required': true };\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'type' validator\r\n   *\r\n   * Requires a control to only accept values of a specified type,\r\n   * or one of an array of types.\r\n   *\r\n   * Note: SchemaPrimitiveType = 'string'|'number'|'integer'|'boolean'|'null'\r\n   *\r\n   * // {SchemaPrimitiveType|SchemaPrimitiveType[]} type - type(s) to accept\r\n   * // {IValidatorFn}\r\n   */\r\n  static type(requiredType: SchemaPrimitiveType|SchemaPrimitiveType[]): IValidatorFn {\r\n    if (!hasValue(requiredType)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue: any = control.value;\r\n      const isValid = isArray(requiredType) ?\r\n        (<SchemaPrimitiveType[]>requiredType).some(type => isType(currentValue, type)) :\r\n        isType(currentValue, <SchemaPrimitiveType>requiredType);\r\n      return xor(isValid, invert) ?\r\n        null : { 'type': { requiredType, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'enum' validator\r\n   *\r\n   * Requires a control to have a value from an enumerated list of values.\r\n   *\r\n   * Converts types as needed to allow string inputs to still correctly\r\n   * match number, boolean, and null enum values.\r\n   *\r\n   * // {any[]} allowedValues - array of acceptable values\r\n   * // {IValidatorFn}\r\n   */\r\n  static enum(allowedValues: any[]): IValidatorFn {\r\n    if (!isArray(allowedValues)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue: any = control.value;\r\n      const isEqualVal = (enumValue, inputValue) =>\r\n        enumValue === inputValue ||\r\n        (isNumber(enumValue) && +inputValue === +enumValue) ||\r\n        (isBoolean(enumValue, 'strict') &&\r\n          toJavaScriptType(inputValue, 'boolean') === enumValue) ||\r\n        (enumValue === null && !hasValue(inputValue)) ||\r\n        isEqual(enumValue, inputValue);\r\n      const isValid = isArray(currentValue) ?\r\n        currentValue.every(inputValue => allowedValues.some(enumValue =>\r\n          isEqualVal(enumValue, inputValue)\r\n        )) :\r\n        allowedValues.some(enumValue => isEqualVal(enumValue, currentValue));\r\n      return xor(isValid, invert) ?\r\n        null : { 'enum': { allowedValues, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'const' validator\r\n   *\r\n   * Requires a control to have a specific value.\r\n   *\r\n   * Converts types as needed to allow string inputs to still correctly\r\n   * match number, boolean, and null values.\r\n   *\r\n   * TODO: modify to work with objects\r\n   *\r\n   * // {any[]} requiredValue - required value\r\n   * // {IValidatorFn}\r\n   */\r\n  static const(requiredValue: any): IValidatorFn {\r\n    if (!hasValue(requiredValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue: any = control.value;\r\n      const isEqualVal = (constValue, inputValue) =>\r\n        constValue === inputValue ||\r\n        isNumber(constValue) && +inputValue === +constValue ||\r\n        isBoolean(constValue, 'strict') &&\r\n          toJavaScriptType(inputValue, 'boolean') === constValue ||\r\n        constValue === null && !hasValue(inputValue);\r\n      const isValid = isEqualVal(requiredValue, currentValue);\r\n      return xor(isValid, invert) ?\r\n        null : { 'const': { requiredValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'minLength' validator\r\n   *\r\n   * Requires a control's text value to be greater than a specified length.\r\n   *\r\n   * // {number} minimumLength - minimum allowed string length\r\n   * // {boolean = false} invert - instead return error object only if valid\r\n   * // {IValidatorFn}\r\n   */\r\n  static minLength(minimumLength: number): IValidatorFn {\r\n    if (!hasValue(minimumLength)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentLength = isString(control.value) ? control.value.length : 0;\r\n      const isValid = currentLength >= minimumLength;\r\n      return xor(isValid, invert) ?\r\n        null : { 'minLength': { minimumLength, currentLength } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'maxLength' validator\r\n   *\r\n   * Requires a control's text value to be less than a specified length.\r\n   *\r\n   * // {number} maximumLength - maximum allowed string length\r\n   * // {boolean = false} invert - instead return error object only if valid\r\n   * // {IValidatorFn}\r\n   */\r\n  static maxLength(maximumLength: number): IValidatorFn {\r\n    if (!hasValue(maximumLength)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const currentLength = isString(control.value) ? control.value.length : 0;\r\n      const isValid = currentLength <= maximumLength;\r\n      return xor(isValid, invert) ?\r\n        null : { 'maxLength': { maximumLength, currentLength } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'pattern' validator\r\n   *\r\n   * Note: NOT the same as Angular's default pattern validator.\r\n   *\r\n   * Requires a control's value to match a specified regular expression pattern.\r\n   *\r\n   * This validator changes the behavior of default pattern validator\r\n   * by replacing RegExp(`^${pattern}$`) with RegExp(`${pattern}`),\r\n   * which allows for partial matches.\r\n   *\r\n   * To return to the default funcitonality, and match the entire string,\r\n   * pass TRUE as the optional second parameter.\r\n   *\r\n   * // {string} pattern - regular expression pattern\r\n   * // {boolean = false} wholeString - match whole value string?\r\n   * // {IValidatorFn}\r\n   */\r\n  static pattern(pattern: string|RegExp, wholeString = false): IValidatorFn {\r\n    if (!hasValue(pattern)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      let regex: RegExp;\r\n      let requiredPattern: string;\r\n      if (typeof pattern === 'string') {\r\n        requiredPattern = (wholeString) ? `^${pattern}$` : pattern;\r\n        regex = new RegExp(requiredPattern);\r\n      } else {\r\n        requiredPattern = pattern.toString();\r\n        regex = pattern;\r\n      }\r\n      const currentValue: string = control.value;\r\n      const isValid = isString(currentValue) ? regex.test(currentValue) : false;\r\n      return xor(isValid, invert) ?\r\n        null : { 'pattern': { requiredPattern, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'format' validator\r\n   *\r\n   * Requires a control to have a value of a certain format.\r\n   *\r\n   * This validator currently checks the following formsts:\r\n   *   date, time, date-time, email, hostname, ipv4, ipv6,\r\n   *   uri, uri-reference, uri-template, url, uuid, color,\r\n   *   json-pointer, relative-json-pointer, regex\r\n   *\r\n   * Fast format regular expressions copied from AJV:\r\n   * https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js\r\n   *\r\n   * // {JsonSchemaFormatNames} requiredFormat - format to check\r\n   * // {IValidatorFn}\r\n   */\r\n  static format(requiredFormat: JsonSchemaFormatNames): IValidatorFn {\r\n    if (!hasValue(requiredFormat)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      let isValid: boolean;\r\n      const currentValue: string|Date = control.value;\r\n      if (isString(currentValue)) {\r\n        const formatTest: Function|RegExp = jsonSchemaFormatTests[requiredFormat];\r\n        if (typeof formatTest === 'object') {\r\n          isValid = (<RegExp>formatTest).test(<string>currentValue);\r\n        } else if (typeof formatTest === 'function') {\r\n          isValid = (<Function>formatTest)(<string>currentValue);\r\n        } else {\r\n          console.error(`format validator error: \"${requiredFormat}\" is not a recognized format.`);\r\n          isValid = true;\r\n        }\r\n      } else {\r\n        // Allow JavaScript Date objects\r\n        isValid = ['date', 'time', 'date-time'].includes(requiredFormat) &&\r\n          Object.prototype.toString.call(currentValue) === '[object Date]';\r\n      }\r\n      return xor(isValid, invert) ?\r\n        null : { 'format': { requiredFormat, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'minimum' validator\r\n   *\r\n   * Requires a control's numeric value to be greater than or equal to\r\n   * a minimum amount.\r\n   *\r\n   * Any non-numeric value is also valid (according to the HTML forms spec,\r\n   * a non-numeric value doesn't have a minimum).\r\n   * https://www.w3.org/TR/html5/forms.html#attr-input-max\r\n   *\r\n   * // {number} minimum - minimum allowed value\r\n   * // {IValidatorFn}\r\n   */\r\n  static minimum(minimumValue: number): IValidatorFn {\r\n    if (!hasValue(minimumValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue = control.value;\r\n      const isValid = !isNumber(currentValue) || currentValue >= minimumValue;\r\n      return xor(isValid, invert) ?\r\n        null : { 'minimum': { minimumValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'exclusiveMinimum' validator\r\n   *\r\n   * Requires a control's numeric value to be less than a maximum amount.\r\n   *\r\n   * Any non-numeric value is also valid (according to the HTML forms spec,\r\n   * a non-numeric value doesn't have a maximum).\r\n   * https://www.w3.org/TR/html5/forms.html#attr-input-max\r\n   *\r\n   * // {number} exclusiveMinimumValue - maximum allowed value\r\n   * // {IValidatorFn}\r\n   */\r\n  static exclusiveMinimum(exclusiveMinimumValue: number): IValidatorFn {\r\n    if (!hasValue(exclusiveMinimumValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue = control.value;\r\n      const isValid = !isNumber(currentValue) || +currentValue < exclusiveMinimumValue;\r\n      return xor(isValid, invert) ?\r\n        null : { 'exclusiveMinimum': { exclusiveMinimumValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'maximum' validator\r\n   *\r\n   * Requires a control's numeric value to be less than or equal to\r\n   * a maximum amount.\r\n   *\r\n   * Any non-numeric value is also valid (according to the HTML forms spec,\r\n   * a non-numeric value doesn't have a maximum).\r\n   * https://www.w3.org/TR/html5/forms.html#attr-input-max\r\n   *\r\n   * // {number} maximumValue - maximum allowed value\r\n   * // {IValidatorFn}\r\n   */\r\n  static maximum(maximumValue: number): IValidatorFn {\r\n    if (!hasValue(maximumValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue = control.value;\r\n      const isValid = !isNumber(currentValue) || +currentValue <= maximumValue;\r\n      return xor(isValid, invert) ?\r\n        null : { 'maximum': { maximumValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'exclusiveMaximum' validator\r\n   *\r\n   * Requires a control's numeric value to be less than a maximum amount.\r\n   *\r\n   * Any non-numeric value is also valid (according to the HTML forms spec,\r\n   * a non-numeric value doesn't have a maximum).\r\n   * https://www.w3.org/TR/html5/forms.html#attr-input-max\r\n   *\r\n   * // {number} exclusiveMaximumValue - maximum allowed value\r\n   * // {IValidatorFn}\r\n   */\r\n  static exclusiveMaximum(exclusiveMaximumValue: number): IValidatorFn {\r\n    if (!hasValue(exclusiveMaximumValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue = control.value;\r\n      const isValid = !isNumber(currentValue) || +currentValue < exclusiveMaximumValue;\r\n      return xor(isValid, invert) ?\r\n        null : { 'exclusiveMaximum': { exclusiveMaximumValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'multipleOf' validator\r\n   *\r\n   * Requires a control to have a numeric value that is a multiple\r\n   * of a specified number.\r\n   *\r\n   * // {number} multipleOfValue - number value must be a multiple of\r\n   * // {IValidatorFn}\r\n   */\r\n  static multipleOf(multipleOfValue: number): IValidatorFn {\r\n    if (!hasValue(multipleOfValue)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentValue = control.value;\r\n      const isValid = isNumber(currentValue) &&\r\n        currentValue % multipleOfValue === 0;\r\n      return xor(isValid, invert) ?\r\n        null : { 'multipleOf': { multipleOfValue, currentValue } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'minProperties' validator\r\n   *\r\n   * Requires a form group to have a minimum number of properties (i.e. have\r\n   * values entered in a minimum number of controls within the group).\r\n   *\r\n   * // {number} minimumProperties - minimum number of properties allowed\r\n   * // {IValidatorFn}\r\n   */\r\n  static minProperties(minimumProperties: number): IValidatorFn {\r\n    if (!hasValue(minimumProperties)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentProperties = Object.keys(control.value).length || 0;\r\n      const isValid = currentProperties >= minimumProperties;\r\n      return xor(isValid, invert) ?\r\n        null : { 'minProperties': { minimumProperties, currentProperties } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'maxProperties' validator\r\n   *\r\n   * Requires a form group to have a maximum number of properties (i.e. have\r\n   * values entered in a maximum number of controls within the group).\r\n   *\r\n   * Note: Has no effect if the form group does not contain more than the\r\n   * maximum number of controls.\r\n   *\r\n   * // {number} maximumProperties - maximum number of properties allowed\r\n   * // {IValidatorFn}\r\n   */\r\n  static maxProperties(maximumProperties: number): IValidatorFn {\r\n    if (!hasValue(maximumProperties)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const currentProperties = Object.keys(control.value).length || 0;\r\n      const isValid = currentProperties <= maximumProperties;\r\n      return xor(isValid, invert) ?\r\n        null : { 'maxProperties': { maximumProperties, currentProperties } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'dependencies' validator\r\n   *\r\n   * Requires the controls in a form group to meet additional validation\r\n   * criteria, depending on the values of other controls in the group.\r\n   *\r\n   * Examples:\r\n   * https://spacetelescope.github.io/understanding-json-schema/reference/object.html#dependencies\r\n   *\r\n   * // {any} dependencies - required dependencies\r\n   * // {IValidatorFn}\r\n   */\r\n  static dependencies(dependencies: any): IValidatorFn {\r\n    if (getType(dependencies) !== 'object' || isEmpty(dependencies)) {\r\n      return JsonValidators.nullValidator;\r\n    }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const allErrors = _mergeObjects(\r\n        forEachCopy(dependencies, (value, requiringField) => {\r\n          if (!hasValue(control.value[requiringField])) { return null; }\r\n          let requiringFieldErrors: ValidationErrors = { };\r\n          let requiredFields: string[];\r\n          let properties: ValidationErrors = { };\r\n          if (getType(dependencies[requiringField]) === 'array') {\r\n            requiredFields = dependencies[requiringField];\r\n          } else if (getType(dependencies[requiringField]) === 'object') {\r\n            requiredFields = dependencies[requiringField]['required'] || [];\r\n            properties = dependencies[requiringField]['properties'] || { };\r\n          }\r\n\r\n          // Validate property dependencies\r\n          for (const requiredField of requiredFields) {\r\n            if (xor(!hasValue(control.value[requiredField]), invert)) {\r\n              requiringFieldErrors[requiredField] = { 'required': true };\r\n            }\r\n          }\r\n\r\n          // Validate schema dependencies\r\n          requiringFieldErrors = _mergeObjects(requiringFieldErrors,\r\n            forEachCopy(properties, (requirements, requiredField) => {\r\n              const requiredFieldErrors = _mergeObjects(\r\n                forEachCopy(requirements, (requirement, parameter) => {\r\n                  let validator: IValidatorFn = null;\r\n                  if (requirement === 'maximum' || requirement === 'minimum') {\r\n                    const exclusive = !!requirements['exclusiveM' + requirement.slice(1)];\r\n                    validator = JsonValidators[requirement](parameter, exclusive);\r\n                  } else if (typeof JsonValidators[requirement] === 'function') {\r\n                    validator = JsonValidators[requirement](parameter);\r\n                  }\r\n                  return !isDefined(validator) ?\r\n                    null : validator(control.value[requiredField]);\r\n                })\r\n              );\r\n              return isEmpty(requiredFieldErrors) ?\r\n                null : { [requiredField]: requiredFieldErrors };\r\n            })\r\n          );\r\n          return isEmpty(requiringFieldErrors) ?\r\n            null : { [requiringField]: requiringFieldErrors };\r\n        })\r\n      );\r\n      return isEmpty(allErrors) ? null : allErrors;\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'minItems' validator\r\n   *\r\n   * Requires a form array to have a minimum number of values.\r\n   *\r\n   * // {number} minimumItems - minimum number of items allowed\r\n   * // {IValidatorFn}\r\n   */\r\n  static minItems(minimumItems: number): IValidatorFn {\r\n    if (!hasValue(minimumItems)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const currentItems = isArray(control.value) ? control.value.length : 0;\r\n      const isValid = currentItems >= minimumItems;\r\n      return xor(isValid, invert) ?\r\n        null : { 'minItems': { minimumItems, currentItems } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'maxItems' validator\r\n   *\r\n   * Requires a form array to have a maximum number of values.\r\n   *\r\n   * // {number} maximumItems - maximum number of items allowed\r\n   * // {IValidatorFn}\r\n   */\r\n  static maxItems(maximumItems: number): IValidatorFn {\r\n    if (!hasValue(maximumItems)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const currentItems = isArray(control.value) ? control.value.length : 0;\r\n      const isValid = currentItems <= maximumItems;\r\n      return xor(isValid, invert) ?\r\n        null : { 'maxItems': { maximumItems, currentItems } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'uniqueItems' validator\r\n   *\r\n   * Requires values in a form array to be unique.\r\n   *\r\n   * // {boolean = true} unique? - true to validate, false to disable\r\n   * // {IValidatorFn}\r\n   */\r\n  static uniqueItems(unique = true): IValidatorFn {\r\n    if (!unique) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const sorted: any[] = control.value.slice().sort();\r\n      const duplicateItems = [];\r\n      for (let i = 1; i < sorted.length; i++) {\r\n        if (sorted[i - 1] === sorted[i] && duplicateItems.includes(sorted[i])) {\r\n          duplicateItems.push(sorted[i]);\r\n        }\r\n      }\r\n      const isValid = !duplicateItems.length;\r\n      return xor(isValid, invert) ?\r\n        null : { 'uniqueItems': { duplicateItems } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'contains' validator\r\n   *\r\n   * TODO: Complete this validator\r\n   *\r\n   * Requires values in a form array to be unique.\r\n   *\r\n   * // {boolean = true} unique? - true to validate, false to disable\r\n   * // {IValidatorFn}\r\n   */\r\n  static contains(requiredItem = true): IValidatorFn {\r\n    if (!requiredItem) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value) || !isArray(control.value)) { return null; }\r\n      const currentItems = control.value;\r\n      // const isValid = currentItems.some(item =>\r\n      //\r\n      // );\r\n      const isValid = true;\r\n      return xor(isValid, invert) ?\r\n        null : { 'contains': { requiredItem, currentItems } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * No-op validator. Included for backward compatibility.\r\n   */\r\n  static nullValidator(control: AbstractControl): ValidationErrors|null {\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Validator transformation functions:\r\n   * composeAnyOf, composeOneOf, composeAllOf, composeNot,\r\n   * compose, composeAsync\r\n   *\r\n   * TODO: Add composeAnyOfAsync, composeOneOfAsync,\r\n   *           composeAllOfAsync, composeNotAsync\r\n   */\r\n\r\n  /**\r\n   * 'composeAnyOf' validator combination function\r\n   *\r\n   * Accepts an array of validators and returns a single validator that\r\n   * evaluates to valid if any one or more of the submitted validators are\r\n   * valid. If every validator is invalid, it returns combined errors from\r\n   * all validators.\r\n   *\r\n   * // {IValidatorFn[]} validators - array of validators to combine\r\n   * // {IValidatorFn} - single combined validator function\r\n   */\r\n  static composeAnyOf(validators: IValidatorFn[]): IValidatorFn {\r\n    if (!validators) { return null; }\r\n    const presentValidators = validators.filter(isDefined);\r\n    if (presentValidators.length === 0) { return null; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const arrayOfErrors =\r\n        _executeValidators(control, presentValidators, invert).filter(isDefined);\r\n      const isValid = validators.length > arrayOfErrors.length;\r\n      return xor(isValid, invert) ?\r\n        null : _mergeObjects(...arrayOfErrors, { 'anyOf': !invert });\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'composeOneOf' validator combination function\r\n   *\r\n   * Accepts an array of validators and returns a single validator that\r\n   * evaluates to valid only if exactly one of the submitted validators\r\n   * is valid. Otherwise returns combined information from all validators,\r\n   * both valid and invalid.\r\n   *\r\n   * // {IValidatorFn[]} validators - array of validators to combine\r\n   * // {IValidatorFn} - single combined validator function\r\n   */\r\n  static composeOneOf(validators: IValidatorFn[]): IValidatorFn {\r\n    if (!validators) { return null; }\r\n    const presentValidators = validators.filter(isDefined);\r\n    if (presentValidators.length === 0) { return null; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const arrayOfErrors =\r\n        _executeValidators(control, presentValidators);\r\n      const validControls =\r\n        validators.length - arrayOfErrors.filter(isDefined).length;\r\n      const isValid = validControls === 1;\r\n      if (xor(isValid, invert)) { return null; }\r\n      const arrayOfValids =\r\n        _executeValidators(control, presentValidators, invert);\r\n      return _mergeObjects(...arrayOfErrors, ...arrayOfValids, { 'oneOf': !invert });\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'composeAllOf' validator combination function\r\n   *\r\n   * Accepts an array of validators and returns a single validator that\r\n   * evaluates to valid only if all the submitted validators are individually\r\n   * valid. Otherwise it returns combined errors from all invalid validators.\r\n   *\r\n   * // {IValidatorFn[]} validators - array of validators to combine\r\n   * // {IValidatorFn} - single combined validator function\r\n   */\r\n  static composeAllOf(validators: IValidatorFn[]): IValidatorFn {\r\n    if (!validators) { return null; }\r\n    const presentValidators = validators.filter(isDefined);\r\n    if (presentValidators.length === 0) { return null; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      const combinedErrors = _mergeErrors(\r\n        _executeValidators(control, presentValidators, invert)\r\n      );\r\n      const isValid = combinedErrors === null;\r\n      return (xor(isValid, invert)) ?\r\n        null : _mergeObjects(combinedErrors, { 'allOf': !invert });\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'composeNot' validator inversion function\r\n   *\r\n   * Accepts a single validator function and inverts its result.\r\n   * Returns valid if the submitted validator is invalid, and\r\n   * returns invalid if the submitted validator is valid.\r\n   * (Note: this function can itself be inverted\r\n   *   - e.g. composeNot(composeNot(validator)) -\r\n   *   but this can be confusing and is therefore not recommended.)\r\n   *\r\n   * // {IValidatorFn[]} validators - validator(s) to invert\r\n   * // {IValidatorFn} - new validator function that returns opposite result\r\n   */\r\n  static composeNot(validator: IValidatorFn): IValidatorFn {\r\n    if (!validator) { return null; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null => {\r\n      if (isEmpty(control.value)) { return null; }\r\n      const error = validator(control, !invert);\r\n      const isValid = error === null;\r\n      return (xor(isValid, invert)) ?\r\n        null : _mergeObjects(error, { 'not': !invert });\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 'compose' validator combination function\r\n   *\r\n   * // {IValidatorFn[]} validators - array of validators to combine\r\n   * // {IValidatorFn} - single combined validator function\r\n   */\r\n  static compose(validators: IValidatorFn[]): IValidatorFn {\r\n    if (!validators) { return null; }\r\n    const presentValidators = validators.filter(isDefined);\r\n    if (presentValidators.length === 0) { return null; }\r\n    return (control: AbstractControl, invert = false): ValidationErrors|null =>\r\n      _mergeErrors(_executeValidators(control, presentValidators, invert));\r\n  }\r\n\r\n  /**\r\n   * 'composeAsync' async validator combination function\r\n   *\r\n   * // {AsyncIValidatorFn[]} async validators - array of async validators\r\n   * // {AsyncIValidatorFn} - single combined async validator function\r\n   */\r\n  static composeAsync(validators: AsyncIValidatorFn[]): AsyncIValidatorFn {\r\n    if (!validators) { return null; }\r\n    const presentValidators = validators.filter(isDefined);\r\n    if (presentValidators.length === 0) { return null; }\r\n    return (control: AbstractControl) => {\r\n      const observables =\r\n        _executeAsyncValidators(control, presentValidators).map(toObservable);\r\n      return map.call(forkJoin(observables), _mergeErrors);\r\n    };\r\n  }\r\n\r\n  // Additional angular validators (not used by Angualr JSON Schema Form)\r\n  // From https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts\r\n\r\n  /**\r\n   * Validator that requires controls to have a value greater than a number.\r\n   */\r\n  static min(min: number): ValidatorFn {\r\n    if (!hasValue(min)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl): ValidationErrors|null => {\r\n      // don't validate empty values to allow optional controls\r\n      if (isEmpty(control.value) || isEmpty(min)) { return null; }\r\n      const value = parseFloat(control.value);\r\n      const actual = control.value;\r\n      // Controls with NaN values after parsing should be treated as not having a\r\n      // minimum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min\r\n      return isNaN(value) || value >= min ? null : { 'min': { min, actual } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Validator that requires controls to have a value less than a number.\r\n   */\r\n  static max(max: number): ValidatorFn {\r\n    if (!hasValue(max)) { return JsonValidators.nullValidator; }\r\n    return (control: AbstractControl): ValidationErrors|null => {\r\n      // don't validate empty values to allow optional controls\r\n      if (isEmpty(control.value) || isEmpty(max)) { return null; }\r\n      const value = parseFloat(control.value);\r\n      const actual = control.value;\r\n      // Controls with NaN values after parsing should be treated as not having a\r\n      // maximum, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-max\r\n      return isNaN(value) || value <= max ? null : { 'max': { max, actual } };\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Validator that requires control value to be true.\r\n   */\r\n  static requiredTrue(control: AbstractControl): ValidationErrors|null {\r\n    if (!control) { return JsonValidators.nullValidator; }\r\n    return control.value === true ? null : { 'required': true };\r\n  }\r\n\r\n  /**\r\n   * Validator that performs email validation.\r\n   */\r\n  static email(control: AbstractControl): ValidationErrors|null {\r\n    if (!control) { return JsonValidators.nullValidator; }\r\n    const EMAIL_REGEXP =\r\n      // tslint:disable-next-line:max-line-length\r\n      /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;\r\n    return EMAIL_REGEXP.test(control.value) ? null : { 'email': true };\r\n  }\r\n}\r\n"]}