@ng-formworks/core 17.2.7 → 17.4.0

package/esm2022/lib/shared/validator.functions.mjs

@@ -0,0 +1,584 @@
+import { from, Observable } from 'rxjs';
+/**
+ * '_executeValidators' utility function
+ *
+ * Validates a control against an array of validators, and returns
+ * an array of the same length containing a combination of error messages
+ * (from invalid validators) and null values (from valid validators)
+ *
+ * //  { AbstractControl } control - control to validate
+ * //  { IValidatorFn[] } validators - array of validators
+ * //  { boolean } invert - invert?
+ * // { PlainObject[] } - array of nulls and error message
+ */
+export function _executeValidators(control, validators, invert = false) {
+    return validators.map(validator => validator(control, invert));
+}
+/**
+ * '_executeAsyncValidators' utility function
+ *
+ * Validates a control against an array of async validators, and returns
+ * an array of observabe results of the same length containing a combination of
+ * error messages (from invalid validators) and null values (from valid ones)
+ *
+ * //  { AbstractControl } control - control to validate
+ * //  { AsyncIValidatorFn[] } validators - array of async validators
+ * //  { boolean } invert - invert?
+ * //  - array of observable nulls and error message
+ */
+export function _executeAsyncValidators(control, validators, invert = false) {
+    return validators.map(validator => validator(control, invert));
+}
+/**
+ * '_mergeObjects' utility function
+ *
+ * Recursively Merges one or more objects into a single object with combined keys.
+ * Automatically detects and ignores null and undefined inputs.
+ * Also detects duplicated boolean 'not' keys and XORs their values.
+ *
+ * //  { PlainObject[] } objects - one or more objects to merge
+ * // { PlainObject } - merged object
+ */
+export function _mergeObjects(...objects) {
+    const mergedObject = {};
+    for (const currentObject of objects) {
+        if (isObject(currentObject)) {
+            for (const key of Object.keys(currentObject)) {
+                const currentValue = currentObject[key];
+                const mergedValue = mergedObject[key];
+                mergedObject[key] = !isDefined(mergedValue) ? currentValue :
+                    key === 'not' && isBoolean(mergedValue, 'strict') &&
+                        isBoolean(currentValue, 'strict') ? xor(mergedValue, currentValue) :
+                        getType(mergedValue) === 'object' && getType(currentValue) === 'object' ?
+                            _mergeObjects(mergedValue, currentValue) :
+                            currentValue;
+            }
+        }
+    }
+    return mergedObject;
+}
+/**
+ * '_mergeErrors' utility function
+ *
+ * Merges an array of objects.
+ * Used for combining the validator errors returned from 'executeValidators'
+ *
+ * //  { PlainObject[] } arrayOfErrors - array of objects
+ * // { PlainObject } - merged object, or null if no usable input objectcs
+ */
+export function _mergeErrors(arrayOfErrors) {
+    const mergedErrors = _mergeObjects(...arrayOfErrors);
+    return isEmpty(mergedErrors) ? null : mergedErrors;
+}
+/**
+ * 'isDefined' utility function
+ *
+ * Checks if a variable contains a value of any type.
+ * Returns true even for otherwise 'falsey' values of 0, '', and false.
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined or null, otherwise true
+ */
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+/**
+ * 'hasValue' utility function
+ *
+ * Checks if a variable contains a value.
+ * Returs false for null, undefined, or a zero-length strng, '',
+ * otherwise returns true.
+ * (Stricter than 'isDefined' because it also returns false for '',
+ * though it stil returns true for otherwise 'falsey' values 0 and false.)
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined, null, or '', otherwise true
+ */
+export function hasValue(value) {
+    return value !== undefined && value !== null && value !== '';
+}
+/**
+ * 'isEmpty' utility function
+ *
+ * Similar to !hasValue, but also returns true for empty arrays and objects.
+ *
+ * //   value - the value to check
+ * // { boolean } - false if undefined, null, or '', otherwise true
+ */
+export function isEmpty(value) {
+    if (isArray(value)) {
+        return !value.length;
+    }
+    if (isObject(value)) {
+        return !Object.keys(value).length;
+    }
+    return value === undefined || value === null || value === '';
+}
+/**
+ * 'isString' utility function
+ *
+ * Checks if a value is a string.
+ *
+ * //   value - the value to check
+ * // { boolean } - true if string, false if not
+ */
+export function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * 'isNumber' utility function
+ *
+ * Checks if a value is a regular number, numeric string, or JavaScript Date.
+ *
+ * //   value - the value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // { boolean } - true if number, false if not
+ */
+export function isNumber(value, strict = false) {
+    if (strict && typeof value !== 'number') {
+        return false;
+    }
+    return !isNaN(value) && value !== value / 0;
+}
+/**
+ * 'isInteger' utility function
+ *
+ * Checks if a value is an integer.
+ *
+ * //   value - the value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // {boolean } - true if number, false if not
+ */
+export function isInteger(value, strict = false) {
+    if (strict && typeof value !== 'number') {
+        return false;
+    }
+    return !isNaN(value) && value !== value / 0 && value % 1 === 0;
+}
+/**
+ * 'isBoolean' utility function
+ *
+ * Checks if a value is a boolean.
+ *
+ * //   value - the value to check
+ * //  { any = null } option - if 'strict', also checks JavaScript type
+ *                              if TRUE or FALSE, checks only for that value
+ * // { boolean } - true if boolean, false if not
+ */
+export function isBoolean(value, option = null) {
+    if (option === 'strict') {
+        return value === true || value === false;
+    }
+    if (option === true) {
+        return value === true || value === 1 || value === 'true' || value === '1';
+    }
+    if (option === false) {
+        return value === false || value === 0 || value === 'false' || value === '0';
+    }
+    return value === true || value === 1 || value === 'true' || value === '1' ||
+        value === false || value === 0 || value === 'false' || value === '0';
+}
+export function isFunction(item) {
+    return typeof item === 'function';
+}
+export function isObject(item) {
+    return item !== null && typeof item === 'object';
+}
+export function isArray(item) {
+    return Array.isArray(item);
+}
+export function isDate(item) {
+    return !!item && Object.prototype.toString.call(item) === '[object Date]';
+}
+export function isMap(item) {
+    return !!item && Object.prototype.toString.call(item) === '[object Map]';
+}
+export function isSet(item) {
+    return !!item && Object.prototype.toString.call(item) === '[object Set]';
+}
+export function isSymbol(item) {
+    return typeof item === 'symbol';
+}
+/**
+ * 'getType' function
+ *
+ * Detects the JSON Schema Type of a value.
+ * By default, detects numbers and integers even if formatted as strings.
+ * (So all integers are also numbers, and any number may also be a string.)
+ * However, it only detects true boolean values (to detect boolean values
+ * in non-boolean formats, use isBoolean() instead).
+ *
+ * If passed a second optional parameter of 'strict', it will only detect
+ * numbers and integers if they are formatted as JavaScript numbers.
+ *
+ * Examples:
+ * getType('10.5') = 'number'
+ * getType(10.5) = 'number'
+ * getType('10') = 'integer'
+ * getType(10) = 'integer'
+ * getType('true') = 'string'
+ * getType(true) = 'boolean'
+ * getType(null) = 'null'
+ * getType({ }) = 'object'
+ * getType([]) = 'array'
+ *
+ * getType('10.5', 'strict') = 'string'
+ * getType(10.5, 'strict') = 'number'
+ * getType('10', 'strict') = 'string'
+ * getType(10, 'strict') = 'integer'
+ * getType('true', 'strict') = 'string'
+ * getType(true, 'strict') = 'boolean'
+ *
+ * //   value - value to check
+ * //  { any = false } strict - if truthy, also checks JavaScript tyoe
+ * // { SchemaType }
+ */
+export function getType(value, strict = false) {
+    if (!isDefined(value)) {
+        return 'null';
+    }
+    if (isArray(value)) {
+        return 'array';
+    }
+    if (isObject(value)) {
+        return 'object';
+    }
+    if (isBoolean(value, 'strict')) {
+        return 'boolean';
+    }
+    if (isInteger(value, strict)) {
+        return 'integer';
+    }
+    if (isNumber(value, strict)) {
+        return 'number';
+    }
+    if (isString(value) || (!strict && isDate(value))) {
+        return 'string';
+    }
+    return null;
+}
+/**
+ * 'isType' function
+ *
+ * Checks wether an input (probably string) value contains data of
+ * a specified JSON Schema type
+ *
+ * //  { PrimitiveValue } value - value to check
+ * //  { SchemaPrimitiveType } type - type to check
+ * // { boolean }
+ */
+export function isType(value, type) {
+    switch (type) {
+        case 'string':
+            return isString(value) || isDate(value);
+        case 'number':
+            return isNumber(value);
+        case 'integer':
+            return isInteger(value);
+        case 'boolean':
+            return isBoolean(value);
+        case 'null':
+            return !hasValue(value);
+        default:
+            console.error(`isType error: "${type}" is not a recognized type.`);
+            return null;
+    }
+}
+/**
+ * 'isPrimitive' function
+ *
+ * Checks wether an input value is a JavaScript primitive type:
+ * string, number, boolean, or null.
+ *
+ * //   value - value to check
+ * // { boolean }
+ */
+export function isPrimitive(value) {
+    return (isString(value) || isNumber(value) ||
+        isBoolean(value, 'strict') || value === null);
+}
+/**
+ *
+ * @param date
+ * @returns {string}
+ * exmaple:
+ * toDateString('2018-01-01') = '2018-01-01'
+ * toDateString('2018-01-30T00:00:00.000Z') = '2018-01-30'
+ */
+export const toIsoString = (date) => {
+    const day = date.getDate();
+    const month = date.getMonth() + 1;
+    const year = date.getFullYear();
+    return `${year}-${month < 10 ? '0' + month : month}-${day < 10 ? '0' + day : day}`;
+};
+/**
+ * 'toJavaScriptType' function
+ *
+ * Converts an input (probably string) value to a JavaScript primitive type -
+ * 'string', 'number', 'boolean', or 'null' - before storing in a JSON object.
+ *
+ * Does not coerce values (other than null), and only converts the types
+ * of values that would otherwise be valid.
+ *
+ * If the optional third parameter 'strictIntegers' is TRUE, and the
+ * JSON Schema type 'integer' is specified, it also verifies the input value
+ * is an integer and, if it is, returns it as a JaveScript number.
+ * If 'strictIntegers' is FALSE (or not set) the type 'integer' is treated
+ * exactly the same as 'number', and allows decimals.
+ *
+ * Valid Examples:
+ * toJavaScriptType('10',   'number' ) = 10   // '10'   is a number
+ * toJavaScriptType('10',   'integer') = 10   // '10'   is also an integer
+ * toJavaScriptType( 10,    'integer') = 10   //  10    is still an integer
+ * toJavaScriptType( 10,    'string' ) = '10' //  10    can be made into a string
+ * toJavaScriptType('10.5', 'number' ) = 10.5 // '10.5' is a number
+ *
+ * Invalid Examples:
+ * toJavaScriptType('10.5', 'integer') = null // '10.5' is not an integer
+ * toJavaScriptType( 10.5,  'integer') = null //  10.5  is still not an integer
+ *
+ * //  { PrimitiveValue } value - value to convert
+ * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - types to convert to
+ * //  { boolean = false } strictIntegers - if FALSE, treat integers as numbers
+ * // { PrimitiveValue }
+ */
+export function toJavaScriptType(value, types, strictIntegers = true) {
+    if (!isDefined(value)) {
+        return null;
+    }
+    if (isString(types)) {
+        types = [types];
+    }
+    if (strictIntegers && inArray('integer', types)) {
+        if (isInteger(value, 'strict')) {
+            return value;
+        }
+        if (isInteger(value)) {
+            return parseInt(value, 10);
+        }
+    }
+    if (inArray('number', types) || (!strictIntegers && inArray('integer', types))) {
+        if (isNumber(value, 'strict')) {
+            return value;
+        }
+        if (isNumber(value)) {
+            return parseFloat(value);
+        }
+    }
+    if (inArray('string', types)) {
+        if (isString(value)) {
+            return value;
+        }
+        // If value is a date, and types includes 'string',
+        // convert the date to a string
+        if (isDate(value)) {
+            return toIsoString(value);
+        }
+        if (isNumber(value)) {
+            return value.toString();
+        }
+    }
+    // If value is a date, and types includes 'integer' or 'number',
+    // but not 'string', convert the date to a number
+    if (isDate(value) && (inArray('integer', types) || inArray('number', types))) {
+        return value.getTime();
+    }
+    if (inArray('boolean', types)) {
+        if (isBoolean(value, true)) {
+            return true;
+        }
+        if (isBoolean(value, false)) {
+            return false;
+        }
+    }
+    return null;
+}
+/**
+ * 'toSchemaType' function
+ *
+ * Converts an input (probably string) value to the "best" JavaScript
+ * equivalent available from an allowed list of JSON Schema types, which may
+ * contain 'string', 'number', 'integer', 'boolean', and/or 'null'.
+ * If necssary, it does progressively agressive type coersion.
+ * It will not return null unless null is in the list of allowed types.
+ *
+ * Number conversion examples:
+ * toSchemaType('10', ['number','integer','string']) = 10 // integer
+ * toSchemaType('10', ['number','string']) = 10 // number
+ * toSchemaType('10', ['string']) = '10' // string
+ * toSchemaType('10.5', ['number','integer','string']) = 10.5 // number
+ * toSchemaType('10.5', ['integer','string']) = '10.5' // string
+ * toSchemaType('10.5', ['integer']) = 10 // integer
+ * toSchemaType(10.5, ['null','boolean','string']) = '10.5' // string
+ * toSchemaType(10.5, ['null','boolean']) = true // boolean
+ *
+ * String conversion examples:
+ * toSchemaType('1.5x', ['boolean','number','integer','string']) = '1.5x' // string
+ * toSchemaType('1.5x', ['boolean','number','integer']) = '1.5' // number
+ * toSchemaType('1.5x', ['boolean','integer']) = '1' // integer
+ * toSchemaType('1.5x', ['boolean']) = true // boolean
+ * toSchemaType('xyz', ['number','integer','boolean','null']) = true // boolean
+ * toSchemaType('xyz', ['number','integer','null']) = null // null
+ * toSchemaType('xyz', ['number','integer']) = 0 // number
+ *
+ * Boolean conversion examples:
+ * toSchemaType('1', ['integer','number','string','boolean']) = 1 // integer
+ * toSchemaType('1', ['number','string','boolean']) = 1 // number
+ * toSchemaType('1', ['string','boolean']) = '1' // string
+ * toSchemaType('1', ['boolean']) = true // boolean
+ * toSchemaType('true', ['number','string','boolean']) = 'true' // string
+ * toSchemaType('true', ['boolean']) = true // boolean
+ * toSchemaType('true', ['number']) = 0 // number
+ * toSchemaType(true, ['number','string','boolean']) = true // boolean
+ * toSchemaType(true, ['number','string']) = 'true' // string
+ * toSchemaType(true, ['number']) = 1 // number
+ *
+ * //  { PrimitiveValue } value - value to convert
+ * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - allowed types to convert to
+ * // { PrimitiveValue }
+ */
+export function toSchemaType(value, types) {
+    if (!isArray(types)) {
+        types = [types];
+    }
+    if (types.includes('null') && !hasValue(value)) {
+        return null;
+    }
+    if (types.includes('boolean') && !isBoolean(value, 'strict')) {
+        return value;
+    }
+    if (types.includes('integer')) {
+        const testValue = toJavaScriptType(value, 'integer');
+        if (testValue !== null) {
+            return +testValue;
+        }
+    }
+    if (types.includes('number')) {
+        const testValue = toJavaScriptType(value, 'number');
+        if (testValue !== null) {
+            return +testValue;
+        }
+    }
+    if ((isString(value) || isNumber(value, 'strict')) &&
+        types.includes('string')) { // Convert number to string
+        return toJavaScriptType(value, 'string');
+    }
+    if (types.includes('boolean') && isBoolean(value)) {
+        return toJavaScriptType(value, 'boolean');
+    }
+    if (types.includes('string')) { // Convert null & boolean to string
+        if (value === null) {
+            return '';
+        }
+        const testValue = toJavaScriptType(value, 'string');
+        if (testValue !== null) {
+            return testValue;
+        }
+    }
+    if ((types.includes('number') ||
+        types.includes('integer'))) {
+        if (value === true) {
+            return 1;
+        } // Convert boolean & null to number
+        if (value === false || value === null || value === '') {
+            return 0;
+        }
+    }
+    if (types.includes('number')) { // Convert mixed string to number
+        const testValue = parseFloat(value);
+        if (!!testValue) {
+            return testValue;
+        }
+    }
+    if (types.includes('integer')) { // Convert string or number to integer
+        const testValue = parseInt(value, 10);
+        if (!!testValue) {
+            return testValue;
+        }
+    }
+    if (types.includes('boolean')) { // Convert anything to boolean
+        return !!value;
+    }
+    if ((types.includes('number') ||
+        types.includes('integer')) && !types.includes('null')) {
+        return 0; // If null not allowed, return 0 for non-convertable values
+    }
+}
+/**
+ * 'isPromise' function
+ *
+ * //   object
+ * // { boolean }
+ */
+export function isPromise(object) {
+    return !!object && typeof object.then === 'function';
+}
+/**
+ * 'isObservable' function
+ *
+ * //   object
+ * // { boolean }
+ */
+export function isObservable(object) {
+    return !!object && typeof object.subscribe === 'function';
+}
+/**
+ * '_toPromise' function
+ *
+ * //  { object } object
+ * // { Promise<any> }
+ */
+export function _toPromise(object) {
+    return isPromise(object) ? object : object.toPromise();
+}
+/**
+ * 'toObservable' function
+ *
+ * //  { object } object
+ * // { Observable<any> }
+ */
+export function toObservable(object) {
+    const observable = isPromise(object) ? from(object) : object;
+    if (isObservable(observable)) {
+        return observable;
+    }
+    console.error('toObservable error: Expected validator to return Promise or Observable.');
+    return new Observable();
+}
+/**
+ * 'inArray' function
+ *
+ * Searches an array for an item, or one of a list of items, and returns true
+ * as soon as a match is found, or false if no match.
+ *
+ * If the optional third parameter allIn is set to TRUE, and the item to find
+ * is an array, then the function returns true only if all elements from item
+ * are found in the array list, and false if any element is not found. If the
+ * item to find is not an array, setting allIn to TRUE has no effect.
+ *
+ * //  { any|any[] } item - the item to search for
+ * //   array - the array to search
+ * //  { boolean = false } allIn - if TRUE, all items must be in array
+ * // { boolean } - true if item(s) in array, false otherwise
+ */
+export function inArray(item, array, allIn = false) {
+    if (!isDefined(item) || !isArray(array)) {
+        return false;
+    }
+    return isArray(item) ?
+        item[allIn ? 'every' : 'some'](subItem => array.includes(subItem)) :
+        array.includes(item);
+}
+/**
+ * 'xor' utility function - exclusive or
+ *
+ * Returns true if exactly one of two values is truthy.
+ *
+ * //   value1 - first value to check
+ * //   value2 - second value to check
+ * // { boolean } - true if exactly one input value is truthy, false if not
+ */
+export function xor(value1, value2) {
+    return (!!value1 && !value2) || (!value1 && !!value2);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validator.functions.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/validator.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl } from '@angular/forms';\r\nimport { from, Observable } from 'rxjs';\r\n\r\n/**\r\n * Validator utility function library:\r\n *\r\n * Validator and error utilities:\r\n *   _executeValidators, _executeAsyncValidators, _mergeObjects, _mergeErrors\r\n *\r\n * Individual value checking:\r\n *   isDefined, hasValue, isEmpty\r\n *\r\n * Individual type checking:\r\n *   isString, isNumber, isInteger, isBoolean, isFunction, isObject, isArray,\r\n *   isMap, isSet, isPromise, isObservable\r\n *\r\n * Multiple type checking and fixing:\r\n *   getType, isType, isPrimitive, toJavaScriptType, toSchemaType,\r\n *   _toPromise, toObservable\r\n *\r\n * Utility functions:\r\n *   inArray, xor\r\n *\r\n * Typescript types and interfaces:\r\n *   SchemaPrimitiveType, SchemaType, JavaScriptPrimitiveType, JavaScriptType,\r\n *   PrimitiveValue, PlainObject, IValidatorFn, AsyncIValidatorFn\r\n *\r\n * Note: 'IValidatorFn' is short for 'invertable validator function',\r\n *   which is a validator functions that accepts an optional second\r\n *   argument which, if set to TRUE, causes the validator to perform\r\n *   the opposite of its original function.\r\n */\r\n\r\nexport type SchemaPrimitiveType =\r\n  'string' | 'number' | 'integer' | 'boolean' | 'null';\r\nexport type SchemaType =\r\n  'string' | 'number' | 'integer' | 'boolean' | 'null' | 'object' | 'array';\r\nexport type JavaScriptPrimitiveType =\r\n  'string' | 'number' | 'boolean' | 'null' | 'undefined';\r\nexport type JavaScriptType =\r\n  'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' |\r\n  'map' | 'set' | 'arguments' | 'date' | 'error' | 'function' | 'json' |\r\n  'math' | 'regexp'; // Note: this list is incomplete\r\nexport type PrimitiveValue = string | number | boolean | null | undefined;\r\nexport interface PlainObject { [k: string]: any; }\r\n\r\nexport type IValidatorFn = (c: AbstractControl, i?: boolean) => PlainObject;\r\nexport type AsyncIValidatorFn = (c: AbstractControl, i?: boolean) => any;\r\n\r\n/**\r\n * '_executeValidators' utility function\r\n *\r\n * Validates a control against an array of validators, and returns\r\n * an array of the same length containing a combination of error messages\r\n * (from invalid validators) and null values (from valid validators)\r\n *\r\n * //  { AbstractControl } control - control to validate\r\n * //  { IValidatorFn[] } validators - array of validators\r\n * //  { boolean } invert - invert?\r\n * // { PlainObject[] } - array of nulls and error message\r\n */\r\nexport function _executeValidators(control, validators, invert = false) {\r\n  return validators.map(validator => validator(control, invert));\r\n}\r\n\r\n/**\r\n * '_executeAsyncValidators' utility function\r\n *\r\n * Validates a control against an array of async validators, and returns\r\n * an array of observabe results of the same length containing a combination of\r\n * error messages (from invalid validators) and null values (from valid ones)\r\n *\r\n * //  { AbstractControl } control - control to validate\r\n * //  { AsyncIValidatorFn[] } validators - array of async validators\r\n * //  { boolean } invert - invert?\r\n * //  - array of observable nulls and error message\r\n */\r\nexport function _executeAsyncValidators(control, validators, invert = false) {\r\n  return validators.map(validator => validator(control, invert));\r\n}\r\n\r\n/**\r\n * '_mergeObjects' utility function\r\n *\r\n * Recursively Merges one or more objects into a single object with combined keys.\r\n * Automatically detects and ignores null and undefined inputs.\r\n * Also detects duplicated boolean 'not' keys and XORs their values.\r\n *\r\n * //  { PlainObject[] } objects - one or more objects to merge\r\n * // { PlainObject } - merged object\r\n */\r\nexport function _mergeObjects(...objects) {\r\n  const mergedObject: PlainObject = { };\r\n  for (const currentObject of objects) {\r\n    if (isObject(currentObject)) {\r\n      for (const key of Object.keys(currentObject)) {\r\n        const currentValue = currentObject[key];\r\n        const mergedValue = mergedObject[key];\r\n        mergedObject[key] = !isDefined(mergedValue) ? currentValue :\r\n          key === 'not' && isBoolean(mergedValue, 'strict') &&\r\n            isBoolean(currentValue, 'strict') ? xor(mergedValue, currentValue) :\r\n          getType(mergedValue) === 'object' && getType(currentValue) === 'object' ?\r\n            _mergeObjects(mergedValue, currentValue) :\r\n            currentValue;\r\n      }\r\n    }\r\n  }\r\n  return mergedObject;\r\n}\r\n\r\n/**\r\n * '_mergeErrors' utility function\r\n *\r\n * Merges an array of objects.\r\n * Used for combining the validator errors returned from 'executeValidators'\r\n *\r\n * //  { PlainObject[] } arrayOfErrors - array of objects\r\n * // { PlainObject } - merged object, or null if no usable input objectcs\r\n */\r\nexport function _mergeErrors(arrayOfErrors) {\r\n  const mergedErrors = _mergeObjects(...arrayOfErrors);\r\n  return isEmpty(mergedErrors) ? null : mergedErrors;\r\n}\r\n\r\n/**\r\n * 'isDefined' utility function\r\n *\r\n * Checks if a variable contains a value of any type.\r\n * Returns true even for otherwise 'falsey' values of 0, '', and false.\r\n *\r\n * //   value - the value to check\r\n * // { boolean } - false if undefined or null, otherwise true\r\n */\r\nexport function isDefined(value) {\r\n  return value !== undefined && value !== null;\r\n}\r\n\r\n/**\r\n * 'hasValue' utility function\r\n *\r\n * Checks if a variable contains a value.\r\n * Returs false for null, undefined, or a zero-length strng, '',\r\n * otherwise returns true.\r\n * (Stricter than 'isDefined' because it also returns false for '',\r\n * though it stil returns true for otherwise 'falsey' values 0 and false.)\r\n *\r\n * //   value - the value to check\r\n * // { boolean } - false if undefined, null, or '', otherwise true\r\n */\r\nexport function hasValue(value) {\r\n  return value !== undefined && value !== null && value !== '';\r\n}\r\n\r\n/**\r\n * 'isEmpty' utility function\r\n *\r\n * Similar to !hasValue, but also returns true for empty arrays and objects.\r\n *\r\n * //   value - the value to check\r\n * // { boolean } - false if undefined, null, or '', otherwise true\r\n */\r\nexport function isEmpty(value) {\r\n  if (isArray(value)) { return !value.length; }\r\n  if (isObject(value)) { return !Object.keys(value).length; }\r\n  return value === undefined || value === null || value === '';\r\n}\r\n\r\n/**\r\n * 'isString' utility function\r\n *\r\n * Checks if a value is a string.\r\n *\r\n * //   value - the value to check\r\n * // { boolean } - true if string, false if not\r\n */\r\nexport function isString(value) {\r\n  return typeof value === 'string';\r\n}\r\n\r\n/**\r\n * 'isNumber' utility function\r\n *\r\n * Checks if a value is a regular number, numeric string, or JavaScript Date.\r\n *\r\n * //   value - the value to check\r\n * //  { any = false } strict - if truthy, also checks JavaScript tyoe\r\n * // { boolean } - true if number, false if not\r\n */\r\nexport function isNumber(value, strict: any = false) {\r\n  if (strict && typeof value !== 'number') { return false; }\r\n  return !isNaN(value) && value !== value / 0;\r\n}\r\n\r\n/**\r\n * 'isInteger' utility function\r\n *\r\n * Checks if a value is an integer.\r\n *\r\n * //   value - the value to check\r\n * //  { any = false } strict - if truthy, also checks JavaScript tyoe\r\n * // {boolean } - true if number, false if not\r\n */\r\nexport function isInteger(value, strict: any = false) {\r\n  if (strict && typeof value !== 'number') { return false; }\r\n  return !isNaN(value) &&  value !== value / 0 && value % 1 === 0;\r\n}\r\n\r\n/**\r\n * 'isBoolean' utility function\r\n *\r\n * Checks if a value is a boolean.\r\n *\r\n * //   value - the value to check\r\n * //  { any = null } option - if 'strict', also checks JavaScript type\r\n *                              if TRUE or FALSE, checks only for that value\r\n * // { boolean } - true if boolean, false if not\r\n */\r\nexport function isBoolean(value, option: any = null) {\r\n  if (option === 'strict') { return value === true || value === false; }\r\n  if (option === true) {\r\n    return value === true || value === 1 || value === 'true' || value === '1';\r\n  }\r\n  if (option === false) {\r\n    return value === false || value === 0 || value === 'false' || value === '0';\r\n  }\r\n  return value === true || value === 1 || value === 'true' || value === '1' ||\r\n    value === false || value === 0 || value === 'false' || value === '0';\r\n}\r\n\r\nexport function isFunction(item: any): boolean {\r\n  return typeof item === 'function';\r\n}\r\n\r\nexport function isObject(item: any): boolean {\r\n  return item !== null && typeof item === 'object';\r\n}\r\n\r\nexport function isArray(item: any): boolean {\r\n  return Array.isArray(item);\r\n}\r\n\r\nexport function isDate(item: any): boolean {\r\n  return !!item && Object.prototype.toString.call(item) === '[object Date]';\r\n}\r\n\r\nexport function isMap(item: any): boolean {\r\n  return !!item && Object.prototype.toString.call(item) === '[object Map]';\r\n}\r\n\r\nexport function isSet(item: any): boolean {\r\n  return !!item && Object.prototype.toString.call(item) === '[object Set]';\r\n}\r\n\r\nexport function isSymbol(item: any): boolean {\r\n  return typeof item === 'symbol';\r\n}\r\n\r\n/**\r\n * 'getType' function\r\n *\r\n * Detects the JSON Schema Type of a value.\r\n * By default, detects numbers and integers even if formatted as strings.\r\n * (So all integers are also numbers, and any number may also be a string.)\r\n * However, it only detects true boolean values (to detect boolean values\r\n * in non-boolean formats, use isBoolean() instead).\r\n *\r\n * If passed a second optional parameter of 'strict', it will only detect\r\n * numbers and integers if they are formatted as JavaScript numbers.\r\n *\r\n * Examples:\r\n * getType('10.5') = 'number'\r\n * getType(10.5) = 'number'\r\n * getType('10') = 'integer'\r\n * getType(10) = 'integer'\r\n * getType('true') = 'string'\r\n * getType(true) = 'boolean'\r\n * getType(null) = 'null'\r\n * getType({ }) = 'object'\r\n * getType([]) = 'array'\r\n *\r\n * getType('10.5', 'strict') = 'string'\r\n * getType(10.5, 'strict') = 'number'\r\n * getType('10', 'strict') = 'string'\r\n * getType(10, 'strict') = 'integer'\r\n * getType('true', 'strict') = 'string'\r\n * getType(true, 'strict') = 'boolean'\r\n *\r\n * //   value - value to check\r\n * //  { any = false } strict - if truthy, also checks JavaScript tyoe\r\n * // { SchemaType }\r\n */\r\nexport function getType(value, strict: any = false) {\r\n  if (!isDefined(value)) { return 'null'; }\r\n  if (isArray(value)) { return 'array'; }\r\n  if (isObject(value)) { return 'object'; }\r\n  if (isBoolean(value, 'strict')) { return 'boolean'; }\r\n  if (isInteger(value, strict)) { return 'integer'; }\r\n  if (isNumber(value, strict)) { return 'number'; }\r\n  if (isString(value) || (!strict && isDate(value))) { return 'string'; }\r\n  return null;\r\n}\r\n\r\n/**\r\n * 'isType' function\r\n *\r\n * Checks wether an input (probably string) value contains data of\r\n * a specified JSON Schema type\r\n *\r\n * //  { PrimitiveValue } value - value to check\r\n * //  { SchemaPrimitiveType } type - type to check\r\n * // { boolean }\r\n */\r\nexport function isType(value, type) {\r\n  switch (type) {\r\n    case 'string':\r\n      return isString(value) || isDate(value);\r\n    case 'number':\r\n      return isNumber(value);\r\n    case 'integer':\r\n      return isInteger(value);\r\n    case 'boolean':\r\n      return isBoolean(value);\r\n    case 'null':\r\n      return !hasValue(value);\r\n    default:\r\n      console.error(`isType error: \"${type}\" is not a recognized type.`);\r\n      return null;\r\n  }\r\n}\r\n\r\n/**\r\n * 'isPrimitive' function\r\n *\r\n * Checks wether an input value is a JavaScript primitive type:\r\n * string, number, boolean, or null.\r\n *\r\n * //   value - value to check\r\n * // { boolean }\r\n */\r\nexport function isPrimitive(value) {\r\n  return (isString(value) || isNumber(value) ||\r\n    isBoolean(value, 'strict') || value === null);\r\n}\r\n\r\n/**\r\n * \r\n * @param date \r\n * @returns {string}\r\n * exmaple:\r\n * toDateString('2018-01-01') = '2018-01-01'\r\n * toDateString('2018-01-30T00:00:00.000Z') = '2018-01-30'\r\n */\r\nexport const toIsoString = (date: Date) => {\r\n  const day = date.getDate();\r\n  const month = date.getMonth() + 1;\r\n  const year = date.getFullYear();\r\n  return `${year}-${month < 10 ? '0' + month : month}-${day < 10 ? '0' + day : day}`;\r\n}\r\n\r\n/**\r\n * 'toJavaScriptType' function\r\n *\r\n * Converts an input (probably string) value to a JavaScript primitive type -\r\n * 'string', 'number', 'boolean', or 'null' - before storing in a JSON object.\r\n *\r\n * Does not coerce values (other than null), and only converts the types\r\n * of values that would otherwise be valid.\r\n *\r\n * If the optional third parameter 'strictIntegers' is TRUE, and the\r\n * JSON Schema type 'integer' is specified, it also verifies the input value\r\n * is an integer and, if it is, returns it as a JaveScript number.\r\n * If 'strictIntegers' is FALSE (or not set) the type 'integer' is treated\r\n * exactly the same as 'number', and allows decimals.\r\n *\r\n * Valid Examples:\r\n * toJavaScriptType('10',   'number' ) = 10   // '10'   is a number\r\n * toJavaScriptType('10',   'integer') = 10   // '10'   is also an integer\r\n * toJavaScriptType( 10,    'integer') = 10   //  10    is still an integer\r\n * toJavaScriptType( 10,    'string' ) = '10' //  10    can be made into a string\r\n * toJavaScriptType('10.5', 'number' ) = 10.5 // '10.5' is a number\r\n *\r\n * Invalid Examples:\r\n * toJavaScriptType('10.5', 'integer') = null // '10.5' is not an integer\r\n * toJavaScriptType( 10.5,  'integer') = null //  10.5  is still not an integer\r\n *\r\n * //  { PrimitiveValue } value - value to convert\r\n * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - types to convert to\r\n * //  { boolean = false } strictIntegers - if FALSE, treat integers as numbers\r\n * // { PrimitiveValue }\r\n */\r\nexport function toJavaScriptType(value, types, strictIntegers = true)  {\r\n  if (!isDefined(value)) { return null; }\r\n  if (isString(types)) { types = [types]; }\r\n  if (strictIntegers && inArray('integer', types)) {\r\n    if (isInteger(value, 'strict')) { return value; }\r\n    if (isInteger(value)) { return parseInt(value, 10); }\r\n  }\r\n  if (inArray('number', types) || (!strictIntegers && inArray('integer', types))) {\r\n    if (isNumber(value, 'strict')) { return value; }\r\n    if (isNumber(value)) { return parseFloat(value); }\r\n  }\r\n  if (inArray('string', types)) {\r\n    if (isString(value)) { return value; }\r\n    // If value is a date, and types includes 'string',\r\n    // convert the date to a string\r\n    if (isDate(value)) { return toIsoString(value); }\r\n    if (isNumber(value)) { return value.toString(); }\r\n  }\r\n  // If value is a date, and types includes 'integer' or 'number',\r\n  // but not 'string', convert the date to a number\r\n  if (isDate(value) && (inArray('integer', types) || inArray('number', types))) {\r\n    return value.getTime();\r\n  }\r\n  if (inArray('boolean', types)) {\r\n    if (isBoolean(value, true)) { return true; }\r\n    if (isBoolean(value, false)) { return false; }\r\n  }\r\n  return null;\r\n}\r\n\r\n/**\r\n * 'toSchemaType' function\r\n *\r\n * Converts an input (probably string) value to the \"best\" JavaScript\r\n * equivalent available from an allowed list of JSON Schema types, which may\r\n * contain 'string', 'number', 'integer', 'boolean', and/or 'null'.\r\n * If necssary, it does progressively agressive type coersion.\r\n * It will not return null unless null is in the list of allowed types.\r\n *\r\n * Number conversion examples:\r\n * toSchemaType('10', ['number','integer','string']) = 10 // integer\r\n * toSchemaType('10', ['number','string']) = 10 // number\r\n * toSchemaType('10', ['string']) = '10' // string\r\n * toSchemaType('10.5', ['number','integer','string']) = 10.5 // number\r\n * toSchemaType('10.5', ['integer','string']) = '10.5' // string\r\n * toSchemaType('10.5', ['integer']) = 10 // integer\r\n * toSchemaType(10.5, ['null','boolean','string']) = '10.5' // string\r\n * toSchemaType(10.5, ['null','boolean']) = true // boolean\r\n *\r\n * String conversion examples:\r\n * toSchemaType('1.5x', ['boolean','number','integer','string']) = '1.5x' // string\r\n * toSchemaType('1.5x', ['boolean','number','integer']) = '1.5' // number\r\n * toSchemaType('1.5x', ['boolean','integer']) = '1' // integer\r\n * toSchemaType('1.5x', ['boolean']) = true // boolean\r\n * toSchemaType('xyz', ['number','integer','boolean','null']) = true // boolean\r\n * toSchemaType('xyz', ['number','integer','null']) = null // null\r\n * toSchemaType('xyz', ['number','integer']) = 0 // number\r\n *\r\n * Boolean conversion examples:\r\n * toSchemaType('1', ['integer','number','string','boolean']) = 1 // integer\r\n * toSchemaType('1', ['number','string','boolean']) = 1 // number\r\n * toSchemaType('1', ['string','boolean']) = '1' // string\r\n * toSchemaType('1', ['boolean']) = true // boolean\r\n * toSchemaType('true', ['number','string','boolean']) = 'true' // string\r\n * toSchemaType('true', ['boolean']) = true // boolean\r\n * toSchemaType('true', ['number']) = 0 // number\r\n * toSchemaType(true, ['number','string','boolean']) = true // boolean\r\n * toSchemaType(true, ['number','string']) = 'true' // string\r\n * toSchemaType(true, ['number']) = 1 // number\r\n *\r\n * //  { PrimitiveValue } value - value to convert\r\n * //  { SchemaPrimitiveType | SchemaPrimitiveType[] } types - allowed types to convert to\r\n * // { PrimitiveValue }\r\n */\r\nexport function toSchemaType(value, types) {\r\n  if (!isArray(<SchemaPrimitiveType>types)) {\r\n    types = <SchemaPrimitiveType[]>[types];\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('null') && !hasValue(value)) {\r\n    return null;\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('boolean') && !isBoolean(value, 'strict')) {\r\n    return value;\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('integer')) {\r\n    const testValue = toJavaScriptType(value, 'integer');\r\n    if (testValue !== null) { return +testValue; }\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('number')) {\r\n    const testValue = toJavaScriptType(value, 'number');\r\n    if (testValue !== null) { return +testValue; }\r\n  }\r\n  if (\r\n    (isString(value) || isNumber(value, 'strict')) &&\r\n    (<SchemaPrimitiveType[]>types).includes('string')\r\n  ) { // Convert number to string\r\n    return toJavaScriptType(value, 'string');\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('boolean') && isBoolean(value)) {\r\n    return toJavaScriptType(value, 'boolean');\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('string')) { // Convert null & boolean to string\r\n    if (value === null) { return ''; }\r\n    const testValue = toJavaScriptType(value, 'string');\r\n    if (testValue !== null) { return testValue; }\r\n  }\r\n  if ((\r\n    (<SchemaPrimitiveType[]>types).includes('number') ||\r\n    (<SchemaPrimitiveType[]>types).includes('integer'))\r\n  ) {\r\n    if (value === true) { return 1; } // Convert boolean & null to number\r\n    if (value === false || value === null || value === '') { return 0; }\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('number')) { // Convert mixed string to number\r\n    const testValue = parseFloat(<string>value);\r\n    if (!!testValue) { return testValue; }\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('integer')) { // Convert string or number to integer\r\n    const testValue = parseInt(<string>value, 10);\r\n    if (!!testValue) { return testValue; }\r\n  }\r\n  if ((<SchemaPrimitiveType[]>types).includes('boolean')) { // Convert anything to boolean\r\n    return !!value;\r\n  }\r\n  if ((\r\n      (<SchemaPrimitiveType[]>types).includes('number') ||\r\n      (<SchemaPrimitiveType[]>types).includes('integer')\r\n    ) && !(<SchemaPrimitiveType[]>types).includes('null')\r\n  ) {\r\n    return 0; // If null not allowed, return 0 for non-convertable values\r\n  }\r\n}\r\n\r\n/**\r\n * 'isPromise' function\r\n *\r\n * //   object\r\n * // { boolean }\r\n */\r\nexport function isPromise(object): object is Promise<any> {\r\n  return !!object && typeof object.then === 'function';\r\n}\r\n\r\n/**\r\n * 'isObservable' function\r\n *\r\n * //   object\r\n * // { boolean }\r\n */\r\nexport function isObservable(object): object is Observable<any> {\r\n  return !!object && typeof object.subscribe === 'function';\r\n}\r\n\r\n/**\r\n * '_toPromise' function\r\n *\r\n * //  { object } object\r\n * // { Promise<any> }\r\n */\r\nexport function _toPromise(object): Promise<any> {\r\n  return isPromise(object) ? object : object.toPromise();\r\n}\r\n\r\n/**\r\n * 'toObservable' function\r\n *\r\n * //  { object } object\r\n * // { Observable<any> }\r\n */\r\nexport function toObservable(object): Observable<any> {\r\n  const observable = isPromise(object) ? from(object) : object;\r\n  if (isObservable(observable)) { return observable; }\r\n  console.error('toObservable error: Expected validator to return Promise or Observable.');\r\n  return new Observable();\r\n}\r\n\r\n/**\r\n * 'inArray' function\r\n *\r\n * Searches an array for an item, or one of a list of items, and returns true\r\n * as soon as a match is found, or false if no match.\r\n *\r\n * If the optional third parameter allIn is set to TRUE, and the item to find\r\n * is an array, then the function returns true only if all elements from item\r\n * are found in the array list, and false if any element is not found. If the\r\n * item to find is not an array, setting allIn to TRUE has no effect.\r\n *\r\n * //  { any|any[] } item - the item to search for\r\n * //   array - the array to search\r\n * //  { boolean = false } allIn - if TRUE, all items must be in array\r\n * // { boolean } - true if item(s) in array, false otherwise\r\n */\r\nexport function inArray(item, array, allIn = false) {\r\n  if (!isDefined(item) || !isArray(array)) { return false; }\r\n  return isArray(item) ?\r\n    item[allIn ? 'every' : 'some'](subItem => array.includes(subItem)) :\r\n    array.includes(item);\r\n}\r\n\r\n/**\r\n * 'xor' utility function - exclusive or\r\n *\r\n * Returns true if exactly one of two values is truthy.\r\n *\r\n * //   value1 - first value to check\r\n * //   value2 - second value to check\r\n * // { boolean } - true if exactly one input value is truthy, false if not\r\n */\r\nexport function xor(value1, value2) {\r\n  return (!!value1 && !value2) || (!value1 && !!value2);\r\n}\r\n"]}