@ajsf/core
Version:
Angular JSON Schema Form builder core
1,358 lines (1,354 loc) • 457 kB
JavaScript
import * as i2 from '@angular/common';
import { CommonModule } from '@angular/common';
import * as i3 from '@angular/forms';
import { UntypedFormControl, UntypedFormArray, UntypedFormGroup, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
import * as i0 from '@angular/core';
import { Injectable, Component, ChangeDetectionStrategy, Input, ViewContainerRef, ViewChild, Directive, Inject, forwardRef, EventEmitter, Output, NgModule } from '@angular/core';
import cloneDeep from 'lodash/cloneDeep';
import isEqual$1 from 'lodash/isEqual';
import { from, Observable, forkJoin, Subject } from 'rxjs';
import { map, takeUntil } from 'rxjs/operators';
import Ajv from 'ajv';
import jsonDraft6 from 'ajv/lib/refs/json-schema-draft-06.json';
import filter from 'lodash/filter';
import map$1 from 'lodash/map';
import uniqueId from 'lodash/uniqueId';
function convertSchemaToDraft6(schema, options = {}) {
let draft = options.draft || null;
let changed = options.changed || false;
if (typeof schema !== 'object') {
return schema;
}
if (typeof schema.map === 'function') {
return [...schema.map(subSchema => convertSchemaToDraft6(subSchema, { changed, draft }))];
}
let newSchema = Object.assign({}, schema);
const simpleTypes = ['array', 'boolean', 'integer', 'null', 'number', 'object', 'string'];
if (typeof newSchema.$schema === 'string' &&
/http\:\/\/json\-schema\.org\/draft\-0\d\/schema\#/.test(newSchema.$schema)) {
draft = newSchema.$schema[30];
}
// Convert v1-v2 'contentEncoding' to 'media.binaryEncoding'
// Note: This is only used in JSON hyper-schema (not regular JSON schema)
if (newSchema.contentEncoding) {
newSchema.media = { binaryEncoding: newSchema.contentEncoding };
delete newSchema.contentEncoding;
changed = true;
}
// Convert v1-v3 'extends' to 'allOf'
if (typeof newSchema.extends === 'object') {
newSchema.allOf = typeof newSchema.extends.map === 'function' ?
newSchema.extends.map(subSchema => convertSchemaToDraft6(subSchema, { changed, draft })) :
[convertSchemaToDraft6(newSchema.extends, { changed, draft })];
delete newSchema.extends;
changed = true;
}
// Convert v1-v3 'disallow' to 'not'
if (newSchema.disallow) {
if (typeof newSchema.disallow === 'string') {
newSchema.not = { type: newSchema.disallow };
}
else if (typeof newSchema.disallow.map === 'function') {
newSchema.not = {
anyOf: newSchema.disallow
.map(type => typeof type === 'object' ? type : { type })
};
}
delete newSchema.disallow;
changed = true;
}
// Convert v3 string 'dependencies' properties to arrays
if (typeof newSchema.dependencies === 'object' &&
Object.keys(newSchema.dependencies)
.some(key => typeof newSchema.dependencies[key] === 'string')) {
newSchema.dependencies = Object.assign({}, newSchema.dependencies);
Object.keys(newSchema.dependencies)
.filter(key => typeof newSchema.dependencies[key] === 'string')
.forEach(key => newSchema.dependencies[key] = [newSchema.dependencies[key]]);
changed = true;
}
// Convert v1 'maxDecimal' to 'multipleOf'
if (typeof newSchema.maxDecimal === 'number') {
newSchema.multipleOf = 1 / Math.pow(10, newSchema.maxDecimal);
delete newSchema.divisibleBy;
changed = true;
if (!draft || draft === 2) {
draft = 1;
}
}
// Convert v2-v3 'divisibleBy' to 'multipleOf'
if (typeof newSchema.divisibleBy === 'number') {
newSchema.multipleOf = newSchema.divisibleBy;
delete newSchema.divisibleBy;
changed = true;
}
// Convert v1-v2 boolean 'minimumCanEqual' to 'exclusiveMinimum'
if (typeof newSchema.minimum === 'number' && newSchema.minimumCanEqual === false) {
newSchema.exclusiveMinimum = newSchema.minimum;
delete newSchema.minimum;
changed = true;
if (!draft) {
draft = 2;
}
}
else if (typeof newSchema.minimumCanEqual === 'boolean') {
delete newSchema.minimumCanEqual;
changed = true;
if (!draft) {
draft = 2;
}
}
// Convert v3-v4 boolean 'exclusiveMinimum' to numeric
if (typeof newSchema.minimum === 'number' && newSchema.exclusiveMinimum === true) {
newSchema.exclusiveMinimum = newSchema.minimum;
delete newSchema.minimum;
changed = true;
}
else if (typeof newSchema.exclusiveMinimum === 'boolean') {
delete newSchema.exclusiveMinimum;
changed = true;
}
// Convert v1-v2 boolean 'maximumCanEqual' to 'exclusiveMaximum'
if (typeof newSchema.maximum === 'number' && newSchema.maximumCanEqual === false) {
newSchema.exclusiveMaximum = newSchema.maximum;
delete newSchema.maximum;
changed = true;
if (!draft) {
draft = 2;
}
}
else if (typeof newSchema.maximumCanEqual === 'boolean') {
delete newSchema.maximumCanEqual;
changed = true;
if (!draft) {
draft = 2;
}
}
// Convert v3-v4 boolean 'exclusiveMaximum' to numeric
if (typeof newSchema.maximum === 'number' && newSchema.exclusiveMaximum === true) {
newSchema.exclusiveMaximum = newSchema.maximum;
delete newSchema.maximum;
changed = true;
}
else if (typeof newSchema.exclusiveMaximum === 'boolean') {
delete newSchema.exclusiveMaximum;
changed = true;
}
// Search object 'properties' for 'optional', 'required', and 'requires' items,
// and convert them into object 'required' arrays and 'dependencies' objects
if (typeof newSchema.properties === 'object') {
const properties = Object.assign({}, newSchema.properties);
const requiredKeys = Array.isArray(newSchema.required) ?
new Set(newSchema.required) : new Set();
// Convert v1-v2 boolean 'optional' properties to 'required' array
if (draft === 1 || draft === 2 ||
Object.keys(properties).some(key => properties[key].optional === true)) {
Object.keys(properties)
.filter(key => properties[key].optional !== true)
.forEach(key => requiredKeys.add(key));
changed = true;
if (!draft) {
draft = 2;
}
}
// Convert v3 boolean 'required' properties to 'required' array
if (Object.keys(properties).some(key => properties[key].required === true)) {
Object.keys(properties)
.filter(key => properties[key].required === true)
.forEach(key => requiredKeys.add(key));
changed = true;
}
if (requiredKeys.size) {
newSchema.required = Array.from(requiredKeys);
}
// Convert v1-v2 array or string 'requires' properties to 'dependencies' object
if (Object.keys(properties).some(key => properties[key].requires)) {
const dependencies = typeof newSchema.dependencies === 'object' ? Object.assign({}, newSchema.dependencies) : {};
Object.keys(properties)
.filter(key => properties[key].requires)
.forEach(key => dependencies[key] =
typeof properties[key].requires === 'string' ?
[properties[key].requires] : properties[key].requires);
newSchema.dependencies = dependencies;
changed = true;
if (!draft) {
draft = 2;
}
}
newSchema.properties = properties;
}
// Revove v1-v2 boolean 'optional' key
if (typeof newSchema.optional === 'boolean') {
delete newSchema.optional;
changed = true;
if (!draft) {
draft = 2;
}
}
// Revove v1-v2 'requires' key
if (newSchema.requires) {
delete newSchema.requires;
}
// Revove v3 boolean 'required' key
if (typeof newSchema.required === 'boolean') {
delete newSchema.required;
}
// Convert id to $id
if (typeof newSchema.id === 'string' && !newSchema.$id) {
if (newSchema.id.slice(-1) === '#') {
newSchema.id = newSchema.id.slice(0, -1);
}
newSchema.$id = newSchema.id + '-CONVERTED-TO-DRAFT-06#';
delete newSchema.id;
changed = true;
}
// Check if v1-v3 'any' or object types will be converted
if (newSchema.type && (typeof newSchema.type.every === 'function' ?
!newSchema.type.every(type => simpleTypes.includes(type)) :
!simpleTypes.includes(newSchema.type))) {
changed = true;
}
// If schema changed, update or remove $schema identifier
if (typeof newSchema.$schema === 'string' &&
/http\:\/\/json\-schema\.org\/draft\-0[1-4]\/schema\#/.test(newSchema.$schema)) {
newSchema.$schema = 'http://json-schema.org/draft-06/schema#';
changed = true;
}
else if (changed && typeof newSchema.$schema === 'string') {
const addToDescription = 'Converted to draft 6 from ' + newSchema.$schema;
if (typeof newSchema.description === 'string' && newSchema.description.length) {
newSchema.description += '\n' + addToDescription;
}
else {
newSchema.description = addToDescription;
}
delete newSchema.$schema;
}
// Convert v1-v3 'any' and object types
if (newSchema.type && (typeof newSchema.type.every === 'function' ?
!newSchema.type.every(type => simpleTypes.includes(type)) :
!simpleTypes.includes(newSchema.type))) {
if (newSchema.type.length === 1) {
newSchema.type = newSchema.type[0];
}
if (typeof newSchema.type === 'string') {
// Convert string 'any' type to array of all standard types
if (newSchema.type === 'any') {
newSchema.type = simpleTypes;
// Delete non-standard string type
}
else {
delete newSchema.type;
}
}
else if (typeof newSchema.type === 'object') {
if (typeof newSchema.type.every === 'function') {
// If array of strings, only allow standard types
if (newSchema.type.every(type => typeof type === 'string')) {
newSchema.type = newSchema.type.some(type => type === 'any') ?
newSchema.type = simpleTypes :
newSchema.type.filter(type => simpleTypes.includes(type));
// If type is an array with objects, convert the current schema to an 'anyOf' array
}
else if (newSchema.type.length > 1) {
const arrayKeys = ['additionalItems', 'items', 'maxItems', 'minItems', 'uniqueItems', 'contains'];
const numberKeys = ['multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum'];
const objectKeys = ['maxProperties', 'minProperties', 'required', 'additionalProperties',
'properties', 'patternProperties', 'dependencies', 'propertyNames'];
const stringKeys = ['maxLength', 'minLength', 'pattern', 'format'];
const filterKeys = {
'array': [...numberKeys, ...objectKeys, ...stringKeys],
'integer': [...arrayKeys, ...objectKeys, ...stringKeys],
'number': [...arrayKeys, ...objectKeys, ...stringKeys],
'object': [...arrayKeys, ...numberKeys, ...stringKeys],
'string': [...arrayKeys, ...numberKeys, ...objectKeys],
'all': [...arrayKeys, ...numberKeys, ...objectKeys, ...stringKeys],
};
const anyOf = [];
for (const type of newSchema.type) {
const newType = typeof type === 'string' ? { type } : Object.assign({}, type);
Object.keys(newSchema)
.filter(key => !newType.hasOwnProperty(key) &&
![...(filterKeys[newType.type] || filterKeys.all), 'type', 'default']
.includes(key))
.forEach(key => newType[key] = newSchema[key]);
anyOf.push(newType);
}
newSchema = newSchema.hasOwnProperty('default') ?
{ anyOf, default: newSchema.default } : { anyOf };
// If type is an object, merge it with the current schema
}
else {
const typeSchema = newSchema.type;
delete newSchema.type;
Object.assign(newSchema, typeSchema);
}
}
}
else {
delete newSchema.type;
}
}
// Convert sub schemas
Object.keys(newSchema)
.filter(key => typeof newSchema[key] === 'object')
.forEach(key => {
if (['definitions', 'dependencies', 'properties', 'patternProperties']
.includes(key) && typeof newSchema[key].map !== 'function') {
const newKey = {};
Object.keys(newSchema[key]).forEach(subKey => newKey[subKey] =
convertSchemaToDraft6(newSchema[key][subKey], { changed, draft }));
newSchema[key] = newKey;
}
else if (['items', 'additionalItems', 'additionalProperties',
'allOf', 'anyOf', 'oneOf', 'not'].includes(key)) {
newSchema[key] = convertSchemaToDraft6(newSchema[key], { changed, draft });
}
else {
newSchema[key] = cloneDeep(newSchema[key]);
}
});
return newSchema;
}
/**
* '_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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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
*/
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';
}
function isFunction(item) {
return typeof item === 'function';
}
function isObject(item) {
return item !== null && typeof item === 'object';
}
function isArray(item) {
return Array.isArray(item);
}
function isDate(item) {
return !!item && Object.prototype.toString.call(item) === '[object Date]';
}
function isMap(item) {
return !!item && Object.prototype.toString.call(item) === '[object Map]';
}
function isSet(item) {
return !!item && Object.prototype.toString.call(item) === '[object Set]';
}
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 }
*/
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 }
*/
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 }
*/
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'
*/
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 }
*/
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 }
*/
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 }
*/
function isPromise(object) {
return !!object && typeof object.then === 'function';
}
/**
* 'isObservable' function
*
* // object
* // { boolean }
*/
function isObservable(object) {
return !!object && typeof object.subscribe === 'function';
}
/**
* '_toPromise' function
*
* // { object } object
* // { Promise<any> }
*/
function _toPromise(object) {
return isPromise(object) ? object : object.toPromise();
}
/**
* 'toObservable' function
*
* // { object } object
* // { Observable<any> }
*/
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
*/
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
*/
function xor(value1, value2) {
return (!!value1 && !value2) || (!value1 && !!value2);
}
/**
* Utility function library:
*
* addClasses, copy, forEach, forEachCopy, hasOwn, mergeFilteredObject,
* uniqueItems, commonItems, fixTitle, toTitleCase
*/
/**
* 'addClasses' function
*
* Merges two space-delimited lists of CSS classes and removes duplicates.
*
* // {string | string[] | Set<string>} oldClasses
* // {string | string[] | Set<string>} newClasses
* // {string | string[] | Set<string>} - Combined classes
*/
function addClasses(oldClasses, newClasses) {
const badType = i => !isSet(i) && !isArray(i) && !isString(i);
if (badType(newClasses)) {
return oldClasses;
}
if (badType(oldClasses)) {
oldClasses = '';
}
const toSet = i => isSet(i) ? i : isArray(i) ? new Set(i) : new Set(i.split(' '));
const combinedSet = toSet(oldClasses);
const newSet = toSet(newClasses);
newSet.forEach(c => combinedSet.add(c));
if (isSet(oldClasses)) {
return combinedSet;
}
if (isArray(oldClasses)) {
return Array.from(combinedSet);
}
return Array.from(combinedSet).join(' ');
}
/**
* 'copy' function
*
* Makes a shallow copy of a JavaScript object, array, Map, or Set.
* If passed a JavaScript primitive value (string, number, boolean, or null),
* it returns the value.
*
* // {Object|Array|string|number|boolean|null} object - The object to copy
* // {boolean = false} errors - Show errors?
* // {Object|Array|string|number|boolean|null} - The copied object
*/
function copy(object, errors = false) {
if (typeof object !== 'object' || object === null) {
return object;
}
if (isMap(object)) {
return new Map(object);
}
if (isSet(object)) {
return new Set(object);
}
if (isArray(object)) {
return [...object];
}
if (isObject(object)) {
return Object.assign({}, object);
}
if (errors) {
console.error('copy error: Object to copy must be a JavaScript object or value.');
}
return object;
}
/**
* 'forEach' function
*
* Iterates over all items in the first level of an object or array
* and calls an iterator funciton on each item.
*
* The iterator function is called with four values:
* 1. The current item's value
* 2. The current item's key
* 3. The parent object, which contains the current item
* 4. The root object
*
* Setting the optional third parameter to 'top-down' or 'bottom-up' will cause
* it to also recursively iterate over items in sub-objects or sub-arrays in the
* specified direction.
*
* // {Object|Array} object - The object or array to iterate over
* // {function} fn - the iterator funciton to call on each item
* // {boolean = false} errors - Show errors?
* // {void}
*/
function forEach(object, fn, recurse = false, rootObject = object, errors = false) {
if (isEmpty(object)) {
return;
}
if ((isObject(object) || isArray(object)) && typeof fn === 'function') {
for (const key of Object.keys(object)) {
const value = object[key];
if (recurse === 'bottom-up' && (isObject(value) || isArray(value))) {
forEach(value, fn, recurse, rootObject);
}
fn(value, key, object, rootObject);
if (recurse === 'top-down' && (isObject(value) || isArray(value))) {
forEach(value, fn, recurse, rootObject);
}
}
}
if (errors) {
if (typeof fn !== 'function') {
console.error('forEach error: Iterator must be a function.');
console.error('function', fn);
}
if (!isObject(object) && !isArray(object)) {
console.error('forEach error: Input object must be an object or array.');
console.error('object', object);
}
}
}
/**
* 'forEachCopy' function
*
* Iterates over all items in the first level of an object or array
* and calls an iterator function on each item. Returns a new object or array
* with the same keys or indexes as the original, and values set to the results
* of the iterator function.
*
* Does NOT recursively iterate over items in sub-objects or sub-arrays.
*
* // {Object | Array} object - The object or array to iterate over
* // {function} fn - The iterator funciton to call on each item
* // {boolean = false} errors - Show errors?
* // {Object | Array} - The resulting object or array
*/
function forEachCopy(object, fn, errors = false) {
if (!hasValue(object)) {
return;
}
if ((isObject(object) || isArray(object)) && typeof object !== 'function') {
const newObject = isArray(object) ? [] : {};
for (const key of Object.keys(object)) {
newObject[key] = fn(object[key], key, object);
}
return newObject;
}
if (errors) {
if (typeof fn !== 'function') {
console.error('forEachCopy error: Iterator must be a function.');
console.error('function', fn);
}
if (!isObject(object) && !isArray(object)) {
console.error('forEachCopy error: Input object must be an object or array.');
console.error('object', object);
}
}
}
/**
* 'hasOwn' utility function
*
* Checks whether an object or array has a particular property.
*
* // {any} object - the object to check
* // {string} property - the property to look for
* // {boolean} - true if object has property, false if not
*/
function hasOwn(object, property) {
if (!object || !['number', 'string', 'symbol'].includes(typeof property) ||
(!isObject(object) && !isArray(object) && !isMap(object) && !isSet(object))) {
return false;
}
if (isMap(object) || isSet(object)) {
return object.has(property);
}
if (typeof property === 'number') {
if (isArray(object)) {
return object[property];
}
property = property + '';
}
return object.hasOwnProperty(property);
}
/**
* Types of possible expressions which the app is able to evaluate.
*/
var ExpressionType;
(function (ExpressionType) {
ExpressionType[ExpressionType["EQUALS"] = 0] = "EQUALS";
ExpressionType[ExpressionType["NOT_EQUALS"] = 1] = "NOT_EQUALS";
ExpressionType[ExpressionType["NOT_AN_EXPRESSION"] = 2] = "NOT_AN_EXPRESSION";
})(ExpressionType || (ExpressionType = {}));
/**
* Detects the type of expression from the given candidate. `==` for equals,
* `!=` for not equals. If none of these are contained in the candidate, the candidate
* is not considered to be an expression at all and thus `NOT_AN_EXPRESSION` is returned.
* // {expressionCandidate} expressionCandidate - potential expression
*/
function getExpressionType(expressionCandidate) {
if (expressionCandidate.indexOf('==') !== -1) {
return ExpressionType.EQUALS;
}
if (expressionCandidate.toString().indexOf('!=') !== -1) {
return ExpressionType.NOT_EQUALS;
}
return ExpressionType.NOT_AN_EXPRESSION;
}
function isEqual(expressionType) {
return expressionType === ExpressionType.EQUALS;
}
function isNotEqual(expressionType) {
return expressionType === ExpressionType.NOT_EQUALS;
}
function isNotExpression(expressionType) {
return expressionType === ExpressionType.NOT_AN_EXPRESSION;
}
/**
* Splits the expression key by the expressionType on a pair of values
* before and after the equals or nor equals sign.
* // {expressionType} enum of an expression type
* // {key} the given key from a for loop iver all conditions
*/
function getKeyAndValueByExpressionType(expressionType, key) {
if (isEqual(expressionType)) {
return key.split('==', 2);
}
if (isNotEqual(expressionType)) {
return key.split('!=', 2);
}
return null;
}
function cleanValueOfQuotes(keyAndValue) {
if (keyAndValue.charAt(0) === '\'' && keyAndValue.charAt(keyAndValue.length - 1) === '\'') {
return keyAndValue.replace('\'', '').replace('\'', '');
}
return keyAndValue;
}
/**
* 'mergeFilteredObject' utility function
*
* Shallowly merges two objects, setting key and values from source object
* in target object, excluding specified keys.
*
* Optionally, it can also use functions to transform the key names and/or
* the values of the merging object.
*
* // {PlainObject} targetObject - Target object to add keys and values to
* // {PlainObject} sourceObject - Source object to copy keys and values from
* // {string[]} excludeKeys - Array of keys to exclude
* // {(string: string) => string = (k) => k} keyFn - Function to apply to keys
* // {(any: any) => any = (v) => v} valueFn - Function to apply to values
* // {PlainObject} - Returns targetObject
*/
function mergeFilteredObject(targetObject, sourceObject, excludeKeys = [], keyFn = (key) => key, valFn = (val) => val) {
if (!isObject(sourceObject)) {
return targetObject;
}
if (!isObject(targetObject)) {
targetObject = {};
}
for (const key of Object.keys(sourceObject)) {
if (!inArray(key, excludeKeys) && isDefined(sourceObject[key])) {
targetObject[keyFn(key)] = valFn(sourceObject[key]);
}
}
return targetObject;
}
/**
* 'uniqueItems' function
*
* Accepts any number of string value inputs,
* and returns an array of all input vaues, excluding duplicates.
*
* // {...string} ...items -
* // {string[]} -
*/
function uniqueItems(...items) {
const returnItems = [];
for (const item of items) {
if (!returnItems.includes(item)) {
returnItems.push(item);
}
}
return returnItems;
}
/**
* 'commonItems' function
*
* Accepts any number of strings or arrays of string values,
* and returns a single array containing only values present in all inputs.
*
* // {...string|string[]} ...arrays -
* // {string[]} -
*/
function commonItems(...arrays) {
let returnItems = null;
for (let array of arrays) {
if (isString(array)) {
array = [array];
}
returnItems = returnItems === null ? [...array] :
returnItems.filter(item => array.includes(item));
if (!returnItems.length) {
return [];
}
}
return returnItems;
}
/**
* 'fixTitle' function
*
*
* // {string} input -
* // {string} -
*/
function fixTitle(name) {
return name && toTitleCase(name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/_/g, ' '));
}
/**
* 'toTitleCase' function
*
* Intelligently converts an input string to Title Case.
*
* Accepts an optional second parameter with a list of additional
* words and abbreviations to force into a particular case.
*
* This function is built on prior work by John Gruber and David Gouch:
* http://daringfireball.net/2008/08/title_case_update
* https://github.com/gouch/to-title-case
*
* // {string} input -
* // {string|string[]} forceWords? -
* // {string} -
*/
function toTitleCase(input, forceWords) {
if (!isString(input)) {
return input;
}
let forceArray = ['a', 'an', 'and', 'as', 'at', 'but', 'by', 'en',
'for', 'if', 'in', 'nor', 'of', 'on', 'or', 'per', 'the', 'to', 'v', 'v.',
'vs', 'vs.', 'via'];
if (isString(forceWords)) {
forceWords = forceWords.split('|');
}
if (isArray(forceWords)) {
forceArray = forceArray.concat(forceWords);
}
const forceArrayLower = forceArray.map(w => w.toLowerCase());
const noInitialCase = input === input.toUpperCase() || input === input.toLowerCase();
let prevLastChar = '';
input = input.trim();
return input.replace(/[A-Za-z0-9\u00C0-\u00FF]+[^\s-]*/g, (word, idx) => {
if (!noInitialCase && word.slice(1).search(/[A-Z]|\../) !== -1) {
return word;
}
else {
let newWord;
const forceWord = forceArray[forceArrayLower.indexOf(word.toLowerCase())];
if (!forceWord) {
if (noInitialCase) {
if (word.slice(1).search(/\../) !== -1) {
newWord = word.toLowerCase();
}
else {
newWord = word[0].toUpperCase() + word.slice(1).toLowerCase();
}
}
else {
newWord = word[0].toUpperCase() + word.slice(1);
}
}
else if (forceWord === forceWord.toLowerCase() && (idx === 0 || idx + word.length === input.length ||
prevLastChar === ':' || input[idx - 1].search(/[^\s-]/) !== -1 ||
(input[idx - 1] !== '-' && input[idx + word.length] === '-'))) {
newWord = forceWord[0].toUpperCase() + forceWord.slice(1);
}
else {
newWord = forceWord;
}
prevLastChar = word.slice(-1);
return newWord;
}
});
}
class JsonPointer {
/**
* 'get' function
*
* Uses a JSON Pointer to retrieve a value from an object.
*
* // { object } object - Object to get value from
* // { Pointer } pointer - JSON Pointer (string or array)
* // { number = 0 } startSlice - Zero-based index of first Pointer key to use
* // { number } endSlice - Zero-based index of last Pointer key to use
* // { boolean = false } getBoolean - Return only true or false?
* // { boolean = false } errors - Show error if not found?
* // { object } - Located value (or true or false if getBoolean = true)
*/
static get(object, pointer, startSlice = 0, endSlice = null, getBoolean = false, errors = false) {
if (object === null) {
return getBoolean ? false : undefined;
}
let keyArray = this.parse(pointer, errors);
if (typeof object === 'object' && keyArray !== null) {
let subObject = object;
if (startSlice >= keyArray.length || endSlice <= -keyArray.length) {
return object;
}
if (startSlice <= -keyArray.length) {
startSlice = 0;
}
if (!isDefined(endSlice) || endSlice >= keyArray.length) {
endSlice = keyArray.length;
}
keyArray = keyArray.slice(startSlice, endSlice);
for (let key of keyArray) {
if (key === '-' && isArray(subObject) && subObject.length) {
key = subObject.length - 1;
}
if (isMap(subObject) && subObject.has(key)) {
subObject = subObject.get(key);
}
else if (typeof subObject === 'object' && subObject !== null &&
hasOwn(subObject, key)) {
subObject = subObject[key];
}
else {
const evaluatedExpression = JsonPointer.evaluateExpression(subObject, key);
if (evaluatedExpression.passed) {
subObject = evaluatedExpression.key ? subObject[evaluatedExpression.key] : subObject;
}
else {
this.logErrors(errors, key, pointer, object);
return getBoolean ? false : undefined;
}
}
}
return getBoolean ? true : subObject;
}
if (errors && keyArray === null) {
console.error(`get error: Invalid JSON Pointer: ${pointer}`);
}
if (errors && typeof object !== 'object') {
console.error('get error: Invalid object:');
console.error(object);
}
return getBoolean ? false : undefined;
}
static logErrors(errors, key, pointer, object) {
if (errors) {
console.error(`get error: "${key}" key not found in object.`);
console.error(pointer);
console.error(object);
}
}
/**
* Evaluates conditional expression in form of `model.<property>==<value>` or
* `model.<property>!=<value>` where the first one means that the value must match to be
* shown in a form, while the former shows the property only when the property value is not
* set, or does not equal the given value.
*
* // { subObject } subObject - an object containing the data values of properties
* // { key } key - the key from the for loop in a form of `<property>==<value>`
*
* Returns the object with two properties. The property passed informs whether
* the expression evaluate