@ng-formworks/core 17.2.7 → 17.4.0

package/esm2022/lib/shared/json-schema.functions.mjs

@@ -0,0 +1,784 @@
+import cloneDeep from 'lodash/cloneDeep';
+import { JsonPointer } from './jsonpointer.functions';
+import { mergeSchemas } from './merge-schemas.function';
+import { forEach, hasOwn, mergeFilteredObject } from './utility.functions';
+import { getType, hasValue, inArray, isArray, isNumber, isObject, isString } from './validator.functions';
+/**
+ * JSON Schema function library:
+ *
+ * buildSchemaFromLayout:   TODO: Write this function
+ *
+ * buildSchemaFromData:
+ *
+ * getFromSchema:
+ *
+ * removeRecursiveReferences:
+ *
+ * getInputType:
+ *
+ * checkInlineType:
+ *
+ * isInputRequired:
+ *
+ * updateInputOptions:
+ *
+ * getTitleMapFromOneOf:
+ *
+ * getControlValidators:
+ *
+ * resolveSchemaReferences:
+ *
+ * getSubSchema:
+ *
+ * combineAllOf:
+ *
+ * fixRequiredArrayProperties:
+ */
+/**
+ * 'buildSchemaFromLayout' function
+ *
+ * TODO: Build a JSON Schema from a JSON Form layout
+ *
+ * //   layout - The JSON Form layout
+ * //  - The new JSON Schema
+ */
+export function buildSchemaFromLayout(layout) {
+    return;
+    // let newSchema: any = { };
+    // const walkLayout = (layoutItems: any[], callback: Function): any[] => {
+    //   let returnArray: any[] = [];
+    //   for (let layoutItem of layoutItems) {
+    //     const returnItem: any = callback(layoutItem);
+    //     if (returnItem) { returnArray = returnArray.concat(callback(layoutItem)); }
+    //     if (layoutItem.items) {
+    //       returnArray = returnArray.concat(walkLayout(layoutItem.items, callback));
+    //     }
+    //   }
+    //   return returnArray;
+    // };
+    // walkLayout(layout, layoutItem => {
+    //   let itemKey: string;
+    //   if (typeof layoutItem === 'string') {
+    //     itemKey = layoutItem;
+    //   } else if (layoutItem.key) {
+    //     itemKey = layoutItem.key;
+    //   }
+    //   if (!itemKey) { return; }
+    //   //
+    // });
+}
+/**
+ * 'buildSchemaFromData' function
+ *
+ * Build a JSON Schema from a data object
+ *
+ * //   data - The data object
+ * //  { boolean = false } requireAllFields - Require all fields?
+ * //  { boolean = true } isRoot - is root
+ * //  - The new JSON Schema
+ */
+export function buildSchemaFromData(data, requireAllFields = false, isRoot = true) {
+    const newSchema = {};
+    const getFieldType = (value) => {
+        const fieldType = getType(value, 'strict');
+        return { integer: 'number', null: 'string' }[fieldType] || fieldType;
+    };
+    const buildSubSchema = (value) => buildSchemaFromData(value, requireAllFields, false);
+    if (isRoot) {
+        newSchema.$schema = 'http://json-schema.org/draft-06/schema#';
+    }
+    newSchema.type = getFieldType(data);
+    if (newSchema.type === 'object') {
+        newSchema.properties = {};
+        if (requireAllFields) {
+            newSchema.required = [];
+        }
+        for (const key of Object.keys(data)) {
+            newSchema.properties[key] = buildSubSchema(data[key]);
+            if (requireAllFields) {
+                newSchema.required.push(key);
+            }
+        }
+    }
+    else if (newSchema.type === 'array') {
+        newSchema.items = data.map(buildSubSchema);
+        // If all items are the same type, use an object for items instead of an array
+        if ((new Set(data.map(getFieldType))).size === 1) {
+            newSchema.items = newSchema.items.reduce((a, b) => ({ ...a, ...b }), {});
+        }
+        if (requireAllFields) {
+            newSchema.minItems = 1;
+        }
+    }
+    return newSchema;
+}
+/**
+ * 'getFromSchema' function
+ *
+ * Uses a JSON Pointer for a value within a data object to retrieve
+ * the schema for that value within schema for the data object.
+ *
+ * The optional third parameter can also be set to return something else:
+ * 'schema' (default): the schema for the value indicated by the data pointer
+ * 'parentSchema': the schema for the value's parent object or array
+ * 'schemaPointer': a pointer to the value's schema within the object's schema
+ * 'parentSchemaPointer': a pointer to the schema for the value's parent object or array
+ *
+ * //   schema - The schema to get the sub-schema from
+ * //  { Pointer } dataPointer - JSON Pointer (string or array)
+ * //  { string = 'schema' } returnType - what to return?
+ * //  - The located sub-schema
+ */
+export function getFromSchema(schema, dataPointer, returnType = 'schema') {
+    const dataPointerArray = JsonPointer.parse(dataPointer);
+    if (dataPointerArray === null) {
+        console.error(`getFromSchema error: Invalid JSON Pointer: ${dataPointer}`);
+        return null;
+    }
+    let subSchema = schema;
+    const schemaPointer = [];
+    const length = dataPointerArray.length;
+    if (returnType.slice(0, 6) === 'parent') {
+        dataPointerArray.length--;
+    }
+    for (let i = 0; i < length; ++i) {
+        const parentSchema = subSchema;
+        const key = dataPointerArray[i];
+        let subSchemaFound = false;
+        if (typeof subSchema !== 'object') {
+            console.error(`getFromSchema error: Unable to find "${key}" key in schema.`);
+            console.error(schema);
+            console.error(dataPointer);
+            return null;
+        }
+        if (subSchema.type === 'array' && (!isNaN(key) || key === '-')) {
+            if (hasOwn(subSchema, 'items')) {
+                if (isObject(subSchema.items)) {
+                    subSchemaFound = true;
+                    subSchema = subSchema.items;
+                    schemaPointer.push('items');
+                }
+                else if (isArray(subSchema.items)) {
+                    if (!isNaN(key) && subSchema.items.length >= +key) {
+                        subSchemaFound = true;
+                        subSchema = subSchema.items[+key];
+                        schemaPointer.push('items', key);
+                    }
+                }
+            }
+            if (!subSchemaFound && isObject(subSchema.additionalItems)) {
+                subSchemaFound = true;
+                subSchema = subSchema.additionalItems;
+                schemaPointer.push('additionalItems');
+            }
+            else if (subSchema.additionalItems !== false) {
+                subSchemaFound = true;
+                subSchema = {};
+                schemaPointer.push('additionalItems');
+            }
+        }
+        else if (subSchema.type === 'object') {
+            if (isObject(subSchema.properties) && hasOwn(subSchema.properties, key)) {
+                subSchemaFound = true;
+                subSchema = subSchema.properties[key];
+                schemaPointer.push('properties', key);
+            }
+            else if (isObject(subSchema.additionalProperties)) {
+                subSchemaFound = true;
+                subSchema = subSchema.additionalProperties;
+                schemaPointer.push('additionalProperties');
+            }
+            else if (subSchema.additionalProperties !== false) {
+                subSchemaFound = true;
+                subSchema = {};
+                schemaPointer.push('additionalProperties');
+            }
+        }
+        if (!subSchemaFound) {
+            console.error(`getFromSchema error: Unable to find "${key}" item in schema.`);
+            console.error(schema);
+            console.error(dataPointer);
+            return;
+        }
+    }
+    return returnType.slice(-7) === 'Pointer' ? schemaPointer : subSchema;
+}
+/**
+ * 'removeRecursiveReferences' function
+ *
+ * Checks a JSON Pointer against a map of recursive references and returns
+ * a JSON Pointer to the shallowest equivalent location in the same object.
+ *
+ * Using this functions enables an object to be constructed with unlimited
+ * recursion, while maintaing a fixed set of metadata, such as field data types.
+ * The object can grow as large as it wants, and deeply recursed nodes can
+ * just refer to the metadata for their shallow equivalents, instead of having
+ * to add additional redundant metadata for each recursively added node.
+ *
+ * Example:
+ *
+ * pointer:         '/stuff/and/more/and/more/and/more/and/more/stuff'
+ * recursiveRefMap: [['/stuff/and/more/and/more', '/stuff/and/more/']]
+ * returned:        '/stuff/and/more/stuff'
+ *
+ * //  { Pointer } pointer -
+ * //  { Map<string, string> } recursiveRefMap -
+ * //  { Map<string, number> = new Map() } arrayMap - optional
+ * // { string } -
+ */
+export function removeRecursiveReferences(pointer, recursiveRefMap, arrayMap = new Map()) {
+    if (!pointer) {
+        return '';
+    }
+    let genericPointer = JsonPointer.toGenericPointer(JsonPointer.compile(pointer), arrayMap);
+    if (genericPointer.indexOf('/') === -1) {
+        return genericPointer;
+    }
+    let possibleReferences = true;
+    while (possibleReferences) {
+        possibleReferences = false;
+        recursiveRefMap.forEach((toPointer, fromPointer) => {
+            if (JsonPointer.isSubPointer(toPointer, fromPointer)) {
+                while (JsonPointer.isSubPointer(fromPointer, genericPointer, true)) {
+                    genericPointer = JsonPointer.toGenericPointer(toPointer + genericPointer.slice(fromPointer.length), arrayMap);
+                    possibleReferences = true;
+                }
+            }
+        });
+    }
+    return genericPointer;
+}
+/**
+ * 'getInputType' function
+ *
+ * //   schema
+ * //  { any = null } layoutNode
+ * // { string }
+ */
+export function getInputType(schema, layoutNode = null) {
+    // x-schema-form = Angular Schema Form compatibility
+    // widget & component = React Jsonschema Form compatibility
+    const controlType = JsonPointer.getFirst([
+        [schema, '/x-schema-form/type'],
+        [schema, '/x-schema-form/widget/component'],
+        [schema, '/x-schema-form/widget'],
+        [schema, '/widget/component'],
+        [schema, '/widget']
+    ]);
+    if (isString(controlType)) {
+        return checkInlineType(controlType, schema, layoutNode);
+    }
+    let schemaType = schema.type;
+    if (schemaType) {
+        if (isArray(schemaType)) { // If multiple types listed, use most inclusive type
+            schemaType =
+                inArray('object', schemaType) && hasOwn(schema, 'properties') ? 'object' :
+                    inArray('array', schemaType) && hasOwn(schema, 'items') ? 'array' :
+                        inArray('array', schemaType) && hasOwn(schema, 'additionalItems') ? 'array' :
+                            inArray('string', schemaType) ? 'string' :
+                                inArray('number', schemaType) ? 'number' :
+                                    inArray('integer', schemaType) ? 'integer' :
+                                        inArray('boolean', schemaType) ? 'boolean' : 'unknown';
+        }
+        if (schemaType === 'boolean') {
+            return 'checkbox';
+        }
+        if (schemaType === 'object') {
+            if (hasOwn(schema, 'properties') || hasOwn(schema, 'additionalProperties')) {
+                return 'section';
+            }
+            // TODO: Figure out how to handle additionalProperties
+            if (hasOwn(schema, '$ref')) {
+                return '$ref';
+            }
+        }
+        if (schemaType === 'array') {
+            const itemsObject = JsonPointer.getFirst([
+                [schema, '/items'],
+                [schema, '/additionalItems']
+            ]) || {};
+            return hasOwn(itemsObject, 'enum') && schema.maxItems !== 1 ?
+                checkInlineType('checkboxes', schema, layoutNode) : 'array';
+        }
+        if (schemaType === 'null') {
+            return 'none';
+        }
+        if (JsonPointer.has(layoutNode, '/options/titleMap') ||
+            hasOwn(schema, 'enum') || getTitleMapFromOneOf(schema, null, true)) {
+            return 'select';
+        }
+        if (schemaType === 'number' || schemaType === 'integer') {
+            return (schemaType === 'integer' || hasOwn(schema, 'multipleOf')) &&
+                hasOwn(schema, 'maximum') && hasOwn(schema, 'minimum') ? 'range' : schemaType;
+        }
+        if (schemaType === 'string') {
+            return {
+                'color': 'color',
+                'date': 'date',
+                'date-time': 'datetime-local',
+                'email': 'email',
+                'uri': 'url',
+            }[schema.format] || 'text';
+        }
+    }
+    if (hasOwn(schema, '$ref')) {
+        return '$ref';
+    }
+    if (isArray(schema.oneOf) || isArray(schema.anyOf)) {
+        return 'one-of';
+    }
+    console.error(`getInputType error: Unable to determine input type for ${schemaType}`);
+    console.error('schema', schema);
+    if (layoutNode) {
+        console.error('layoutNode', layoutNode);
+    }
+    return 'none';
+}
+/**
+ * 'checkInlineType' function
+ *
+ * Checks layout and schema nodes for 'inline: true', and converts
+ * 'radios' or 'checkboxes' to 'radios-inline' or 'checkboxes-inline'
+ *
+ * //  { string } controlType -
+ * //   schema -
+ * //  { any = null } layoutNode -
+ * // { string }
+ */
+export function checkInlineType(controlType, schema, layoutNode = null) {
+    if (!isString(controlType) || (controlType.slice(0, 8) !== 'checkbox' && controlType.slice(0, 5) !== 'radio')) {
+        return controlType;
+    }
+    if (JsonPointer.getFirst([
+        [layoutNode, '/inline'],
+        [layoutNode, '/options/inline'],
+        [schema, '/inline'],
+        [schema, '/x-schema-form/inline'],
+        [schema, '/x-schema-form/options/inline'],
+        [schema, '/x-schema-form/widget/inline'],
+        [schema, '/x-schema-form/widget/component/inline'],
+        [schema, '/x-schema-form/widget/component/options/inline'],
+        [schema, '/widget/inline'],
+        [schema, '/widget/component/inline'],
+        [schema, '/widget/component/options/inline'],
+    ]) === true) {
+        return controlType.slice(0, 5) === 'radio' ?
+            'radios-inline' : 'checkboxes-inline';
+    }
+    else {
+        return controlType;
+    }
+}
+/**
+ * 'isInputRequired' function
+ *
+ * Checks a JSON Schema to see if an item is required
+ *
+ * //   schema - the schema to check
+ * //  { string } schemaPointer - the pointer to the item to check
+ * // { boolean } - true if the item is required, false if not
+ */
+export function isInputRequired(schema, schemaPointer) {
+    if (!isObject(schema)) {
+        console.error('isInputRequired error: Input schema must be an object.');
+        return false;
+    }
+    const listPointerArray = JsonPointer.parse(schemaPointer);
+    if (isArray(listPointerArray)) {
+        if (!listPointerArray.length) {
+            return schema.required === true;
+        }
+        const keyName = listPointerArray.pop();
+        const nextToLastKey = listPointerArray[listPointerArray.length - 1];
+        if (['properties', 'additionalProperties', 'patternProperties', 'items', 'additionalItems']
+            .includes(nextToLastKey)) {
+            listPointerArray.pop();
+        }
+        const parentSchema = JsonPointer.get(schema, listPointerArray) || {};
+        if (isArray(parentSchema.required)) {
+            return parentSchema.required.includes(keyName);
+        }
+        if (parentSchema.type === 'array') {
+            return hasOwn(parentSchema, 'minItems') &&
+                isNumber(keyName) &&
+                +parentSchema.minItems > +keyName;
+        }
+    }
+    return false;
+}
+/**
+ * 'updateInputOptions' function
+ *
+ * //   layoutNode
+ * //   schema
+ * //   jsf
+ * // { void }
+ */
+export function updateInputOptions(layoutNode, schema, jsf) {
+    if (!isObject(layoutNode) || !isObject(layoutNode.options)) {
+        return;
+    }
+    // Set all option values in layoutNode.options
+    const newOptions = {};
+    const fixUiKeys = key => key.slice(0, 3).toLowerCase() === 'ui:' ? key.slice(3) : key;
+    mergeFilteredObject(newOptions, jsf.formOptions.defaultWidgetOptions, [], fixUiKeys);
+    [[JsonPointer.get(schema, '/ui:widget/options'), []],
+        [JsonPointer.get(schema, '/ui:widget'), []],
+        [schema, [
+                'additionalProperties', 'additionalItems', 'properties', 'items',
+                'required', 'type', 'x-schema-form', '$ref'
+            ]],
+        [JsonPointer.get(schema, '/x-schema-form/options'), []],
+        [JsonPointer.get(schema, '/x-schema-form'), ['items', 'options']],
+        [layoutNode, [
+                '_id', '$ref', 'arrayItem', 'arrayItemType', 'dataPointer', 'dataType',
+                'items', 'key', 'name', 'options', 'recursiveReference', 'type', 'widget'
+            ]],
+        [layoutNode.options, []],
+    ].forEach(([object, excludeKeys]) => mergeFilteredObject(newOptions, object, excludeKeys, fixUiKeys));
+    if (!hasOwn(newOptions, 'titleMap')) {
+        let newTitleMap = null;
+        newTitleMap = getTitleMapFromOneOf(schema, newOptions.flatList);
+        if (newTitleMap) {
+            newOptions.titleMap = newTitleMap;
+        }
+        if (!hasOwn(newOptions, 'titleMap') && !hasOwn(newOptions, 'enum') && hasOwn(schema, 'items')) {
+            if (JsonPointer.has(schema, '/items/titleMap')) {
+                newOptions.titleMap = schema.items.titleMap;
+            }
+            else if (JsonPointer.has(schema, '/items/enum')) {
+                newOptions.enum = schema.items.enum;
+                if (!hasOwn(newOptions, 'enumNames') && JsonPointer.has(schema, '/items/enumNames')) {
+                    newOptions.enumNames = schema.items.enumNames;
+                }
+            }
+            else if (JsonPointer.has(schema, '/items/oneOf')) {
+                newTitleMap = getTitleMapFromOneOf(schema.items, newOptions.flatList);
+                if (newTitleMap) {
+                    newOptions.titleMap = newTitleMap;
+                }
+            }
+        }
+    }
+    // If schema type is integer, enforce by setting multipleOf = 1
+    if (schema.type === 'integer' && !hasValue(newOptions.multipleOf)) {
+        newOptions.multipleOf = 1;
+    }
+    // Copy any typeahead word lists to options.typeahead.source
+    if (JsonPointer.has(newOptions, '/autocomplete/source')) {
+        newOptions.typeahead = newOptions.autocomplete;
+    }
+    else if (JsonPointer.has(newOptions, '/tagsinput/source')) {
+        newOptions.typeahead = newOptions.tagsinput;
+    }
+    else if (JsonPointer.has(newOptions, '/tagsinput/typeahead/source')) {
+        newOptions.typeahead = newOptions.tagsinput.typeahead;
+    }
+    layoutNode.options = newOptions;
+}
+/**
+ * 'getTitleMapFromOneOf' function
+ *
+ * //  { schema } schema
+ * //  { boolean = null } flatList
+ * //  { boolean = false } validateOnly
+ * // { validators }
+ */
+export function getTitleMapFromOneOf(schema = {}, flatList = null, validateOnly = false) {
+    let titleMap = null;
+    const oneOf = schema.oneOf || schema.anyOf || null;
+    if (isArray(oneOf) && oneOf.every(item => item.title)) {
+        if (oneOf.every(item => isArray(item.enum) && item.enum.length === 1)) {
+            if (validateOnly) {
+                return true;
+            }
+            titleMap = oneOf.map(item => ({ name: item.title, value: item.enum[0] }));
+        }
+        else if (oneOf.every(item => item.const)) {
+            if (validateOnly) {
+                return true;
+            }
+            titleMap = oneOf.map(item => ({ name: item.title, value: item.const }));
+        }
+        // if flatList !== false and some items have colons, make grouped map
+        if (flatList !== false && (titleMap || [])
+            .filter(title => ((title || {}).name || '').indexOf(': ')).length > 1) {
+            // Split name on first colon to create grouped map (name -> group: name)
+            const newTitleMap = titleMap.map(title => {
+                const [group, name] = title.name.split(/: (.+)/);
+                return group && name ? { ...title, group, name } : title;
+            });
+            // If flatList === true or at least one group has multiple items, use grouped map
+            if (flatList === true || newTitleMap.some((title, index) => index &&
+                hasOwn(title, 'group') && title.group === newTitleMap[index - 1].group)) {
+                titleMap = newTitleMap;
+            }
+        }
+    }
+    return validateOnly ? false : titleMap;
+}
+/**
+ * 'getControlValidators' function
+ *
+ * //  schema
+ * // { validators }
+ */
+export function getControlValidators(schema) {
+    if (!isObject(schema)) {
+        return null;
+    }
+    const validators = {};
+    if (hasOwn(schema, 'type')) {
+        switch (schema.type) {
+            case 'string':
+                forEach(['pattern', 'format', 'minLength', 'maxLength'], (prop) => {
+                    if (hasOwn(schema, prop)) {
+                        validators[prop] = [schema[prop]];
+                    }
+                });
+                break;
+            case 'number':
+            case 'integer':
+                forEach(['Minimum', 'Maximum'], (ucLimit) => {
+                    const eLimit = 'exclusive' + ucLimit;
+                    const limit = ucLimit.toLowerCase();
+                    if (hasOwn(schema, limit)) {
+                        const exclusive = hasOwn(schema, eLimit) && schema[eLimit] === true;
+                        validators[limit] = [schema[limit], exclusive];
+                    }
+                });
+                forEach(['multipleOf', 'type'], (prop) => {
+                    if (hasOwn(schema, prop)) {
+                        validators[prop] = [schema[prop]];
+                    }
+                });
+                break;
+            case 'object':
+                forEach(['minProperties', 'maxProperties', 'dependencies'], (prop) => {
+                    if (hasOwn(schema, prop)) {
+                        validators[prop] = [schema[prop]];
+                    }
+                });
+                break;
+            case 'array':
+                forEach(['minItems', 'maxItems', 'uniqueItems'], (prop) => {
+                    if (hasOwn(schema, prop)) {
+                        validators[prop] = [schema[prop]];
+                    }
+                });
+                break;
+        }
+    }
+    if (hasOwn(schema, 'enum')) {
+        validators.enum = [schema.enum];
+    }
+    return validators;
+}
+/**
+ * 'resolveSchemaReferences' function
+ *
+ * Find all $ref links in schema and save links and referenced schemas in
+ * schemaRefLibrary, schemaRecursiveRefMap, and dataRecursiveRefMap
+ *
+ * //  schema
+ * //  schemaRefLibrary
+ * // { Map<string, string> } schemaRecursiveRefMap
+ * // { Map<string, string> } dataRecursiveRefMap
+ * // { Map<string, number> } arrayMap
+ * //
+ */
+export function resolveSchemaReferences(schema, schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, arrayMap) {
+    if (!isObject(schema)) {
+        console.error('resolveSchemaReferences error: schema must be an object.');
+        return;
+    }
+    const refLinks = new Set();
+    const refMapSet = new Set();
+    const refMap = new Map();
+    const recursiveRefMap = new Map();
+    const refLibrary = {};
+    // Search schema for all $ref links, and build full refLibrary
+    JsonPointer.forEachDeep(schema, (subSchema, subSchemaPointer) => {
+        if (hasOwn(subSchema, '$ref') && isString(subSchema['$ref'])) {
+            const refPointer = JsonPointer.compile(subSchema['$ref']);
+            refLinks.add(refPointer);
+            refMapSet.add(subSchemaPointer + '~~' + refPointer);
+            refMap.set(subSchemaPointer, refPointer);
+        }
+    });
+    refLinks.forEach(ref => refLibrary[ref] = getSubSchema(schema, ref));
+    // Follow all ref links and save in refMapSet,
+    // to find any multi-link recursive refernces
+    let checkRefLinks = true;
+    while (checkRefLinks) {
+        checkRefLinks = false;
+        Array.from(refMap).forEach(([fromRef1, toRef1]) => Array.from(refMap)
+            .filter(([fromRef2, toRef2]) => JsonPointer.isSubPointer(toRef1, fromRef2, true) &&
+            !JsonPointer.isSubPointer(toRef2, toRef1, true) &&
+            !refMapSet.has(fromRef1 + fromRef2.slice(toRef1.length) + '~~' + toRef2))
+            .forEach(([fromRef2, toRef2]) => {
+            refMapSet.add(fromRef1 + fromRef2.slice(toRef1.length) + '~~' + toRef2);
+            checkRefLinks = true;
+        }));
+    }
+    // Build full recursiveRefMap
+    // First pass - save all internally recursive refs from refMapSet
+    Array.from(refMapSet)
+        .map(refLink => refLink.split('~~'))
+        .filter(([fromRef, toRef]) => JsonPointer.isSubPointer(toRef, fromRef))
+        .forEach(([fromRef, toRef]) => recursiveRefMap.set(fromRef, toRef));
+    // Second pass - create recursive versions of any other refs that link to recursive refs
+    Array.from(refMap)
+        .filter(([fromRef1, toRef1]) => Array.from(recursiveRefMap.keys())
+        .every(fromRef2 => !JsonPointer.isSubPointer(fromRef1, fromRef2, true)))
+        .forEach(([fromRef1, toRef1]) => Array.from(recursiveRefMap)
+        .filter(([fromRef2, toRef2]) => !recursiveRefMap.has(fromRef1 + fromRef2.slice(toRef1.length)) &&
+        JsonPointer.isSubPointer(toRef1, fromRef2, true) &&
+        !JsonPointer.isSubPointer(toRef1, fromRef1, true))
+        .forEach(([fromRef2, toRef2]) => recursiveRefMap.set(fromRef1 + fromRef2.slice(toRef1.length), fromRef1 + toRef2.slice(toRef1.length))));
+    // Create compiled schema by replacing all non-recursive $ref links with
+    // thieir linked schemas and, where possible, combining schemas in allOf arrays.
+    let compiledSchema = { ...schema };
+    delete compiledSchema.definitions;
+    compiledSchema =
+        getSubSchema(compiledSchema, '', refLibrary, recursiveRefMap);
+    // Make sure all remaining schema $refs are recursive, and build final
+    // schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, & arrayMap
+    JsonPointer.forEachDeep(compiledSchema, (subSchema, subSchemaPointer) => {
+        if (isString(subSchema['$ref'])) {
+            let refPointer = JsonPointer.compile(subSchema['$ref']);
+            if (!JsonPointer.isSubPointer(refPointer, subSchemaPointer, true)) {
+                refPointer = removeRecursiveReferences(subSchemaPointer, recursiveRefMap);
+                JsonPointer.set(compiledSchema, subSchemaPointer, { $ref: `#${refPointer}` });
+            }
+            if (!hasOwn(schemaRefLibrary, 'refPointer')) {
+                schemaRefLibrary[refPointer] = !refPointer.length ? compiledSchema :
+                    getSubSchema(compiledSchema, refPointer, schemaRefLibrary, recursiveRefMap);
+            }
+            if (!schemaRecursiveRefMap.has(subSchemaPointer)) {
+                schemaRecursiveRefMap.set(subSchemaPointer, refPointer);
+            }
+            const fromDataRef = JsonPointer.toDataPointer(subSchemaPointer, compiledSchema);
+            if (!dataRecursiveRefMap.has(fromDataRef)) {
+                const toDataRef = JsonPointer.toDataPointer(refPointer, compiledSchema);
+                dataRecursiveRefMap.set(fromDataRef, toDataRef);
+            }
+        }
+        if (subSchema.type === 'array' &&
+            (hasOwn(subSchema, 'items') || hasOwn(subSchema, 'additionalItems'))) {
+            const dataPointer = JsonPointer.toDataPointer(subSchemaPointer, compiledSchema);
+            if (!arrayMap.has(dataPointer)) {
+                const tupleItems = isArray(subSchema.items) ? subSchema.items.length : 0;
+                arrayMap.set(dataPointer, tupleItems);
+            }
+        }
+    }, true);
+    return compiledSchema;
+}
+/**
+ * 'getSubSchema' function
+ *
+ * //   schema
+ * //  { Pointer } pointer
+ * //  { object } schemaRefLibrary
+ * //  { Map<string, string> } schemaRecursiveRefMap
+ * //  { string[] = [] } usedPointers
+ * //
+ */
+export function getSubSchema(schema, pointer, schemaRefLibrary = null, schemaRecursiveRefMap = null, usedPointers = []) {
+    if (!schemaRefLibrary || !schemaRecursiveRefMap) {
+        return JsonPointer.getCopy(schema, pointer);
+    }
+    if (typeof pointer !== 'string') {
+        pointer = JsonPointer.compile(pointer);
+    }
+    usedPointers = [...usedPointers, pointer];
+    let newSchema = null;
+    if (pointer === '') {
+        newSchema = cloneDeep(schema);
+    }
+    else {
+        const shortPointer = removeRecursiveReferences(pointer, schemaRecursiveRefMap);
+        if (shortPointer !== pointer) {
+            usedPointers = [...usedPointers, shortPointer];
+        }
+        newSchema = JsonPointer.getFirstCopy([
+            [schemaRefLibrary, [shortPointer]],
+            [schema, pointer],
+            [schema, shortPointer]
+        ]);
+    }
+    return JsonPointer.forEachDeepCopy(newSchema, (subSchema, subPointer) => {
+        if (isObject(subSchema)) {
+            // Replace non-recursive $ref links with referenced schemas
+            if (isString(subSchema.$ref)) {
+                const refPointer = JsonPointer.compile(subSchema.$ref);
+                if (refPointer.length && usedPointers.every(ptr => !JsonPointer.isSubPointer(refPointer, ptr, true))) {
+                    const refSchema = getSubSchema(schema, refPointer, schemaRefLibrary, schemaRecursiveRefMap, usedPointers);
+                    if (Object.keys(subSchema).length === 1) {
+                        return refSchema;
+                    }
+                    else {
+                        const extraKeys = { ...subSchema };
+                        delete extraKeys.$ref;
+                        return mergeSchemas(refSchema, extraKeys);
+                    }
+                }
+            }
+            // TODO: Convert schemas with 'type' arrays to 'oneOf'
+            // Combine allOf subSchemas
+            if (isArray(subSchema.allOf)) {
+                return combineAllOf(subSchema);
+            }
+            // Fix incorrectly placed array object required lists
+            if (subSchema.type === 'array' && isArray(subSchema.required)) {
+                return fixRequiredArrayProperties(subSchema);
+            }
+        }
+        return subSchema;
+    }, true, pointer);
+}
+/**
+ * 'combineAllOf' function
+ *
+ * Attempt to convert an allOf schema object into
+ * a non-allOf schema object with equivalent rules.
+ *
+ * //   schema - allOf schema object
+ * //  - converted schema object
+ */
+export function combineAllOf(schema) {
+    if (!isObject(schema) || !isArray(schema.allOf)) {
+        return schema;
+    }
+    let mergedSchema = mergeSchemas(...schema.allOf);
+    if (Object.keys(schema).length > 1) {
+        const extraKeys = { ...schema };
+        delete extraKeys.allOf;
+        mergedSchema = mergeSchemas(mergedSchema, extraKeys);
+    }
+    return mergedSchema;
+}
+/**
+ * 'fixRequiredArrayProperties' function
+ *
+ * Fixes an incorrectly placed required list inside an array schema, by moving
+ * it into items.properties or additionalItems.properties, where it belongs.
+ *
+ * //   schema - allOf schema object
+ * //  - converted schema object
+ */
+export function fixRequiredArrayProperties(schema) {
+    if (schema.type === 'array' && isArray(schema.required)) {
+        const itemsObject = hasOwn(schema.items, 'properties') ? 'items' :
+            hasOwn(schema.additionalItems, 'properties') ? 'additionalItems' : null;
+        if (itemsObject && !hasOwn(schema[itemsObject], 'required') && (hasOwn(schema[itemsObject], 'additionalProperties') ||
+            schema.required.every(key => hasOwn(schema[itemsObject].properties, key)))) {
+            schema = cloneDeep(schema);
+            schema[itemsObject].required = schema.required;
+            delete schema.required;
+        }
+    }
+    return schema;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema.functions.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/json-schema.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import cloneDeep from 'lodash/cloneDeep';\r\nimport { JsonPointer } from './jsonpointer.functions';\r\nimport { mergeSchemas } from './merge-schemas.function';\r\nimport { forEach, hasOwn, mergeFilteredObject } from './utility.functions';\r\nimport {\r\n    getType,\r\n    hasValue,\r\n    inArray,\r\n    isArray,\r\n    isNumber,\r\n    isObject,\r\n    isString\r\n} from './validator.functions';\r\n\r\n\r\n/**\r\n * JSON Schema function library:\r\n *\r\n * buildSchemaFromLayout:   TODO: Write this function\r\n *\r\n * buildSchemaFromData:\r\n *\r\n * getFromSchema:\r\n *\r\n * removeRecursiveReferences:\r\n *\r\n * getInputType:\r\n *\r\n * checkInlineType:\r\n *\r\n * isInputRequired:\r\n *\r\n * updateInputOptions:\r\n *\r\n * getTitleMapFromOneOf:\r\n *\r\n * getControlValidators:\r\n *\r\n * resolveSchemaReferences:\r\n *\r\n * getSubSchema:\r\n *\r\n * combineAllOf:\r\n *\r\n * fixRequiredArrayProperties:\r\n */\r\n\r\n/**\r\n * 'buildSchemaFromLayout' function\r\n *\r\n * TODO: Build a JSON Schema from a JSON Form layout\r\n *\r\n * //   layout - The JSON Form layout\r\n * //  - The new JSON Schema\r\n */\r\nexport function buildSchemaFromLayout(layout) {\r\n  return;\r\n  // let newSchema: any = { };\r\n  // const walkLayout = (layoutItems: any[], callback: Function): any[] => {\r\n  //   let returnArray: any[] = [];\r\n  //   for (let layoutItem of layoutItems) {\r\n  //     const returnItem: any = callback(layoutItem);\r\n  //     if (returnItem) { returnArray = returnArray.concat(callback(layoutItem)); }\r\n  //     if (layoutItem.items) {\r\n  //       returnArray = returnArray.concat(walkLayout(layoutItem.items, callback));\r\n  //     }\r\n  //   }\r\n  //   return returnArray;\r\n  // };\r\n  // walkLayout(layout, layoutItem => {\r\n  //   let itemKey: string;\r\n  //   if (typeof layoutItem === 'string') {\r\n  //     itemKey = layoutItem;\r\n  //   } else if (layoutItem.key) {\r\n  //     itemKey = layoutItem.key;\r\n  //   }\r\n  //   if (!itemKey) { return; }\r\n  //   //\r\n  // });\r\n}\r\n\r\n/**\r\n * 'buildSchemaFromData' function\r\n *\r\n * Build a JSON Schema from a data object\r\n *\r\n * //   data - The data object\r\n * //  { boolean = false } requireAllFields - Require all fields?\r\n * //  { boolean = true } isRoot - is root\r\n * //  - The new JSON Schema\r\n */\r\nexport function buildSchemaFromData(\r\n  data, requireAllFields = false, isRoot = true\r\n) {\r\n  const newSchema: any = {};\r\n  const getFieldType = (value: any): string => {\r\n    const fieldType = getType(value, 'strict');\r\n    return { integer: 'number', null: 'string' }[fieldType] || fieldType;\r\n  };\r\n  const buildSubSchema = (value) =>\r\n    buildSchemaFromData(value, requireAllFields, false);\r\n  if (isRoot) { newSchema.$schema = 'http://json-schema.org/draft-06/schema#'; }\r\n  newSchema.type = getFieldType(data);\r\n  if (newSchema.type === 'object') {\r\n    newSchema.properties = {};\r\n    if (requireAllFields) { newSchema.required = []; }\r\n    for (const key of Object.keys(data)) {\r\n      newSchema.properties[key] = buildSubSchema(data[key]);\r\n      if (requireAllFields) { newSchema.required.push(key); }\r\n    }\r\n  } else if (newSchema.type === 'array') {\r\n    newSchema.items = data.map(buildSubSchema);\r\n    // If all items are the same type, use an object for items instead of an array\r\n    if ((new Set(data.map(getFieldType))).size === 1) {\r\n      newSchema.items = newSchema.items.reduce((a, b) => ({ ...a, ...b }), {});\r\n    }\r\n    if (requireAllFields) { newSchema.minItems = 1; }\r\n  }\r\n  return newSchema;\r\n}\r\n\r\n/**\r\n * 'getFromSchema' function\r\n *\r\n * Uses a JSON Pointer for a value within a data object to retrieve\r\n * the schema for that value within schema for the data object.\r\n *\r\n * The optional third parameter can also be set to return something else:\r\n * 'schema' (default): the schema for the value indicated by the data pointer\r\n * 'parentSchema': the schema for the value's parent object or array\r\n * 'schemaPointer': a pointer to the value's schema within the object's schema\r\n * 'parentSchemaPointer': a pointer to the schema for the value's parent object or array\r\n *\r\n * //   schema - The schema to get the sub-schema from\r\n * //  { Pointer } dataPointer - JSON Pointer (string or array)\r\n * //  { string = 'schema' } returnType - what to return?\r\n * //  - The located sub-schema\r\n */\r\nexport function getFromSchema(schema, dataPointer, returnType = 'schema') {\r\n  const dataPointerArray: any[] = JsonPointer.parse(dataPointer);\r\n  if (dataPointerArray === null) {\r\n    console.error(`getFromSchema error: Invalid JSON Pointer: ${dataPointer}`);\r\n    return null;\r\n  }\r\n  let subSchema = schema;\r\n  const schemaPointer = [];\r\n  const length = dataPointerArray.length;\r\n  if (returnType.slice(0, 6) === 'parent') { dataPointerArray.length--; }\r\n  for (let i = 0; i < length; ++i) {\r\n    const parentSchema = subSchema;\r\n    const key = dataPointerArray[i];\r\n    let subSchemaFound = false;\r\n    if (typeof subSchema !== 'object') {\r\n      console.error(`getFromSchema error: Unable to find \"${key}\" key in schema.`);\r\n      console.error(schema);\r\n      console.error(dataPointer);\r\n      return null;\r\n    }\r\n    if (subSchema.type === 'array' && (!isNaN(key) || key === '-')) {\r\n      if (hasOwn(subSchema, 'items')) {\r\n        if (isObject(subSchema.items)) {\r\n          subSchemaFound = true;\r\n          subSchema = subSchema.items;\r\n          schemaPointer.push('items');\r\n        } else if (isArray(subSchema.items)) {\r\n          if (!isNaN(key) && subSchema.items.length >= +key) {\r\n            subSchemaFound = true;\r\n            subSchema = subSchema.items[+key];\r\n            schemaPointer.push('items', key);\r\n          }\r\n        }\r\n      }\r\n      if (!subSchemaFound && isObject(subSchema.additionalItems)) {\r\n        subSchemaFound = true;\r\n        subSchema = subSchema.additionalItems;\r\n        schemaPointer.push('additionalItems');\r\n      } else if (subSchema.additionalItems !== false) {\r\n        subSchemaFound = true;\r\n        subSchema = { };\r\n        schemaPointer.push('additionalItems');\r\n      }\r\n    } else if (subSchema.type === 'object') {\r\n      if (isObject(subSchema.properties) && hasOwn(subSchema.properties, key)) {\r\n        subSchemaFound = true;\r\n        subSchema = subSchema.properties[key];\r\n        schemaPointer.push('properties', key);\r\n      } else if (isObject(subSchema.additionalProperties)) {\r\n        subSchemaFound = true;\r\n        subSchema = subSchema.additionalProperties;\r\n        schemaPointer.push('additionalProperties');\r\n      } else if (subSchema.additionalProperties !== false) {\r\n        subSchemaFound = true;\r\n        subSchema = { };\r\n        schemaPointer.push('additionalProperties');\r\n      }\r\n    }\r\n    if (!subSchemaFound) {\r\n      console.error(`getFromSchema error: Unable to find \"${key}\" item in schema.`);\r\n      console.error(schema);\r\n      console.error(dataPointer);\r\n      return;\r\n    }\r\n  }\r\n  return returnType.slice(-7) === 'Pointer' ? schemaPointer : subSchema;\r\n}\r\n\r\n/**\r\n * 'removeRecursiveReferences' function\r\n *\r\n * Checks a JSON Pointer against a map of recursive references and returns\r\n * a JSON Pointer to the shallowest equivalent location in the same object.\r\n *\r\n * Using this functions enables an object to be constructed with unlimited\r\n * recursion, while maintaing a fixed set of metadata, such as field data types.\r\n * The object can grow as large as it wants, and deeply recursed nodes can\r\n * just refer to the metadata for their shallow equivalents, instead of having\r\n * to add additional redundant metadata for each recursively added node.\r\n *\r\n * Example:\r\n *\r\n * pointer:         '/stuff/and/more/and/more/and/more/and/more/stuff'\r\n * recursiveRefMap: [['/stuff/and/more/and/more', '/stuff/and/more/']]\r\n * returned:        '/stuff/and/more/stuff'\r\n *\r\n * //  { Pointer } pointer -\r\n * //  { Map<string, string> } recursiveRefMap -\r\n * //  { Map<string, number> = new Map() } arrayMap - optional\r\n * // { string } -\r\n */\r\nexport function removeRecursiveReferences(\r\n  pointer, recursiveRefMap, arrayMap = new Map()\r\n) {\r\n  if (!pointer) { return ''; }\r\n  let genericPointer =\r\n    JsonPointer.toGenericPointer(JsonPointer.compile(pointer), arrayMap);\r\n  if (genericPointer.indexOf('/') === -1) { return genericPointer; }\r\n  let possibleReferences = true;\r\n  while (possibleReferences) {\r\n    possibleReferences = false;\r\n    recursiveRefMap.forEach((toPointer, fromPointer) => {\r\n      if (JsonPointer.isSubPointer(toPointer, fromPointer)) {\r\n        while (JsonPointer.isSubPointer(fromPointer, genericPointer, true)) {\r\n          genericPointer = JsonPointer.toGenericPointer(\r\n            toPointer + genericPointer.slice(fromPointer.length), arrayMap\r\n          );\r\n          possibleReferences = true;\r\n        }\r\n      }\r\n    });\r\n  }\r\n  return genericPointer;\r\n}\r\n\r\n/**\r\n * 'getInputType' function\r\n *\r\n * //   schema\r\n * //  { any = null } layoutNode\r\n * // { string }\r\n */\r\nexport function getInputType(schema, layoutNode: any = null) {\r\n  // x-schema-form = Angular Schema Form compatibility\r\n  // widget & component = React Jsonschema Form compatibility\r\n  const controlType = JsonPointer.getFirst([\r\n    [schema, '/x-schema-form/type'],\r\n    [schema, '/x-schema-form/widget/component'],\r\n    [schema, '/x-schema-form/widget'],\r\n    [schema, '/widget/component'],\r\n    [schema, '/widget']\r\n  ]);\r\n  if (isString(controlType)) { return checkInlineType(controlType, schema, layoutNode); }\r\n  let schemaType = schema.type;\r\n  if (schemaType) {\r\n    if (isArray(schemaType)) { // If multiple types listed, use most inclusive type\r\n      schemaType =\r\n        inArray('object', schemaType) && hasOwn(schema, 'properties') ? 'object' :\r\n        inArray('array', schemaType) && hasOwn(schema, 'items') ? 'array' :\r\n        inArray('array', schemaType) && hasOwn(schema, 'additionalItems') ? 'array' :\r\n        inArray('string', schemaType) ? 'string' :\r\n        inArray('number', schemaType) ? 'number' :\r\n        inArray('integer', schemaType) ? 'integer' :\r\n        inArray('boolean', schemaType) ? 'boolean' : 'unknown';\r\n    }\r\n    if (schemaType === 'boolean') { return 'checkbox'; }\r\n    if (schemaType === 'object') {\r\n      if (hasOwn(schema, 'properties') || hasOwn(schema, 'additionalProperties')) {\r\n        return 'section';\r\n      }\r\n      // TODO: Figure out how to handle additionalProperties\r\n      if (hasOwn(schema, '$ref')) { return '$ref'; }\r\n    }\r\n    if (schemaType === 'array') {\r\n      const itemsObject = JsonPointer.getFirst([\r\n        [schema, '/items'],\r\n        [schema, '/additionalItems']\r\n      ]) || {};\r\n      return hasOwn(itemsObject, 'enum') && schema.maxItems !== 1 ?\r\n        checkInlineType('checkboxes', schema, layoutNode) : 'array';\r\n    }\r\n    if (schemaType === 'null') { return 'none'; }\r\n    if (JsonPointer.has(layoutNode, '/options/titleMap') ||\r\n      hasOwn(schema, 'enum') || getTitleMapFromOneOf(schema, null, true)\r\n    ) { return 'select'; }\r\n    if (schemaType === 'number' || schemaType === 'integer') {\r\n      return (schemaType === 'integer' || hasOwn(schema, 'multipleOf')) &&\r\n        hasOwn(schema, 'maximum') && hasOwn(schema, 'minimum') ? 'range' : schemaType;\r\n    }\r\n    if (schemaType === 'string') {\r\n      return {\r\n        'color': 'color',\r\n        'date': 'date',\r\n        'date-time': 'datetime-local',\r\n        'email': 'email',\r\n        'uri': 'url',\r\n      }[schema.format] || 'text';\r\n    }\r\n  }\r\n  if (hasOwn(schema, '$ref')) { return '$ref'; }\r\n  if (isArray(schema.oneOf) || isArray(schema.anyOf)) { return 'one-of'; }\r\n  console.error(`getInputType error: Unable to determine input type for ${schemaType}`);\r\n  console.error('schema', schema);\r\n  if (layoutNode) { console.error('layoutNode', layoutNode); }\r\n  return 'none';\r\n}\r\n\r\n/**\r\n * 'checkInlineType' function\r\n *\r\n * Checks layout and schema nodes for 'inline: true', and converts\r\n * 'radios' or 'checkboxes' to 'radios-inline' or 'checkboxes-inline'\r\n *\r\n * //  { string } controlType -\r\n * //   schema -\r\n * //  { any = null } layoutNode -\r\n * // { string }\r\n */\r\nexport function checkInlineType(controlType, schema, layoutNode: any = null) {\r\n  if (!isString(controlType) || (\r\n    controlType.slice(0, 8) !== 'checkbox' && controlType.slice(0, 5) !== 'radio'\r\n  )) {\r\n    return controlType;\r\n  }\r\n  if (\r\n    JsonPointer.getFirst([\r\n      [layoutNode, '/inline'],\r\n      [layoutNode, '/options/inline'],\r\n      [schema, '/inline'],\r\n      [schema, '/x-schema-form/inline'],\r\n      [schema, '/x-schema-form/options/inline'],\r\n      [schema, '/x-schema-form/widget/inline'],\r\n      [schema, '/x-schema-form/widget/component/inline'],\r\n      [schema, '/x-schema-form/widget/component/options/inline'],\r\n      [schema, '/widget/inline'],\r\n      [schema, '/widget/component/inline'],\r\n      [schema, '/widget/component/options/inline'],\r\n    ]) === true\r\n  ) {\r\n    return controlType.slice(0, 5) === 'radio' ?\r\n      'radios-inline' : 'checkboxes-inline';\r\n  } else {\r\n    return controlType;\r\n  }\r\n}\r\n\r\n/**\r\n * 'isInputRequired' function\r\n *\r\n * Checks a JSON Schema to see if an item is required\r\n *\r\n * //   schema - the schema to check\r\n * //  { string } schemaPointer - the pointer to the item to check\r\n * // { boolean } - true if the item is required, false if not\r\n */\r\nexport function isInputRequired(schema, schemaPointer) {\r\n  if (!isObject(schema)) {\r\n    console.error('isInputRequired error: Input schema must be an object.');\r\n    return false;\r\n  }\r\n  const listPointerArray = JsonPointer.parse(schemaPointer);\r\n  if (isArray(listPointerArray)) {\r\n    if (!listPointerArray.length) { return schema.required === true; }\r\n    const keyName = listPointerArray.pop();\r\n    const nextToLastKey = listPointerArray[listPointerArray.length - 1];\r\n    if (['properties', 'additionalProperties', 'patternProperties', 'items', 'additionalItems']\r\n      .includes(nextToLastKey)\r\n    ) {\r\n      listPointerArray.pop();\r\n    }\r\n    const parentSchema = JsonPointer.get(schema, listPointerArray) || {};\r\n    if (isArray(parentSchema.required)) {\r\n      return parentSchema.required.includes(keyName);\r\n    }\r\n    if (parentSchema.type === 'array') {\r\n      return hasOwn(parentSchema, 'minItems') &&\r\n        isNumber(keyName) &&\r\n        +parentSchema.minItems > +keyName;\r\n    }\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * 'updateInputOptions' function\r\n *\r\n * //   layoutNode\r\n * //   schema\r\n * //   jsf\r\n * // { void }\r\n */\r\nexport function updateInputOptions(layoutNode, schema, jsf) {\r\n  if (!isObject(layoutNode) || !isObject(layoutNode.options)) { return; }\r\n\r\n  // Set all option values in layoutNode.options\r\n  const newOptions: any = { };\r\n  const fixUiKeys = key => key.slice(0, 3).toLowerCase() === 'ui:' ? key.slice(3) : key;\r\n  mergeFilteredObject(newOptions, jsf.formOptions.defaultWidgetOptions, [], fixUiKeys);\r\n  [ [ JsonPointer.get(schema, '/ui:widget/options'), [] ],\r\n    [ JsonPointer.get(schema, '/ui:widget'), [] ],\r\n    [ schema, [\r\n      'additionalProperties', 'additionalItems', 'properties', 'items',\r\n      'required', 'type', 'x-schema-form', '$ref'\r\n    ] ],\r\n    [ JsonPointer.get(schema, '/x-schema-form/options'), [] ],\r\n    [ JsonPointer.get(schema, '/x-schema-form'), ['items', 'options'] ],\r\n    [ layoutNode, [\r\n      '_id', '$ref', 'arrayItem', 'arrayItemType', 'dataPointer', 'dataType',\r\n      'items', 'key', 'name', 'options', 'recursiveReference', 'type', 'widget'\r\n    ] ],\r\n    [ layoutNode.options, [] ],\r\n  ].forEach(([ object, excludeKeys ]) =>\r\n    mergeFilteredObject(newOptions, object, excludeKeys, fixUiKeys)\r\n  );\r\n  if (!hasOwn(newOptions, 'titleMap')) {\r\n    let newTitleMap: any = null;\r\n    newTitleMap = getTitleMapFromOneOf(schema, newOptions.flatList);\r\n    if (newTitleMap) { newOptions.titleMap = newTitleMap; }\r\n    if (!hasOwn(newOptions, 'titleMap') && !hasOwn(newOptions, 'enum') && hasOwn(schema, 'items')) {\r\n      if (JsonPointer.has(schema, '/items/titleMap')) {\r\n        newOptions.titleMap = schema.items.titleMap;\r\n      } else if (JsonPointer.has(schema, '/items/enum')) {\r\n        newOptions.enum = schema.items.enum;\r\n        if (!hasOwn(newOptions, 'enumNames') && JsonPointer.has(schema, '/items/enumNames')) {\r\n          newOptions.enumNames = schema.items.enumNames;\r\n        }\r\n      } else if (JsonPointer.has(schema, '/items/oneOf')) {\r\n        newTitleMap = getTitleMapFromOneOf(schema.items, newOptions.flatList);\r\n        if (newTitleMap) { newOptions.titleMap = newTitleMap; }\r\n      }\r\n    }\r\n  }\r\n\r\n  // If schema type is integer, enforce by setting multipleOf = 1\r\n  if (schema.type === 'integer' && !hasValue(newOptions.multipleOf)) {\r\n    newOptions.multipleOf = 1;\r\n  }\r\n\r\n  // Copy any typeahead word lists to options.typeahead.source\r\n  if (JsonPointer.has(newOptions, '/autocomplete/source')) {\r\n    newOptions.typeahead = newOptions.autocomplete;\r\n  } else if (JsonPointer.has(newOptions, '/tagsinput/source')) {\r\n    newOptions.typeahead = newOptions.tagsinput;\r\n  } else if (JsonPointer.has(newOptions, '/tagsinput/typeahead/source')) {\r\n    newOptions.typeahead = newOptions.tagsinput.typeahead;\r\n  }\r\n\r\n  layoutNode.options = newOptions;\r\n}\r\n\r\n/**\r\n * 'getTitleMapFromOneOf' function\r\n *\r\n * //  { schema } schema\r\n * //  { boolean = null } flatList\r\n * //  { boolean = false } validateOnly\r\n * // { validators }\r\n */\r\nexport function getTitleMapFromOneOf(\r\n  schema: any = {}, flatList: boolean = null, validateOnly = false\r\n) {\r\n  let titleMap = null;\r\n  const oneOf = schema.oneOf || schema.anyOf || null;\r\n  if (isArray(oneOf) && oneOf.every(item => item.title)) {\r\n    if (oneOf.every(item => isArray(item.enum) && item.enum.length === 1)) {\r\n      if (validateOnly) { return true; }\r\n      titleMap = oneOf.map(item => ({ name: item.title, value: item.enum[0] }));\r\n    } else if (oneOf.every(item => item.const)) {\r\n      if (validateOnly) { return true; }\r\n      titleMap = oneOf.map(item => ({ name: item.title, value: item.const }));\r\n    }\r\n\r\n    // if flatList !== false and some items have colons, make grouped map\r\n    if (flatList !== false && (titleMap || [])\r\n      .filter(title => ((title || {}).name || '').indexOf(': ')).length > 1\r\n    ) {\r\n\r\n      // Split name on first colon to create grouped map (name -> group: name)\r\n      const newTitleMap = titleMap.map(title => {\r\n        const [group, name] = title.name.split(/: (.+)/);\r\n        return group && name ? { ...title, group, name } : title;\r\n      });\r\n\r\n      // If flatList === true or at least one group has multiple items, use grouped map\r\n      if (flatList === true || newTitleMap.some((title, index) => index &&\r\n        hasOwn(title, 'group') && title.group === newTitleMap[index - 1].group\r\n      )) {\r\n        titleMap = newTitleMap;\r\n      }\r\n    }\r\n  }\r\n  return validateOnly ? false : titleMap;\r\n}\r\n\r\n/**\r\n * 'getControlValidators' function\r\n *\r\n * //  schema\r\n * // { validators }\r\n */\r\nexport function getControlValidators(schema) {\r\n  if (!isObject(schema)) { return null; }\r\n  const validators: any = { };\r\n  if (hasOwn(schema, 'type')) {\r\n    switch (schema.type) {\r\n      case 'string':\r\n        forEach(['pattern', 'format', 'minLength', 'maxLength'], (prop) => {\r\n          if (hasOwn(schema, prop)) { validators[prop] = [schema[prop]]; }\r\n        });\r\n      break;\r\n      case 'number': case 'integer':\r\n        forEach(['Minimum', 'Maximum'], (ucLimit) => {\r\n          const eLimit = 'exclusive' + ucLimit;\r\n          const limit = ucLimit.toLowerCase();\r\n          if (hasOwn(schema, limit)) {\r\n            const exclusive = hasOwn(schema, eLimit) && schema[eLimit] === true;\r\n            validators[limit] = [schema[limit], exclusive];\r\n          }\r\n        });\r\n        forEach(['multipleOf', 'type'], (prop) => {\r\n          if (hasOwn(schema, prop)) { validators[prop] = [schema[prop]]; }\r\n        });\r\n      break;\r\n      case 'object':\r\n        forEach(['minProperties', 'maxProperties', 'dependencies'], (prop) => {\r\n          if (hasOwn(schema, prop)) { validators[prop] = [schema[prop]]; }\r\n        });\r\n      break;\r\n      case 'array':\r\n        forEach(['minItems', 'maxItems', 'uniqueItems'], (prop) => {\r\n          if (hasOwn(schema, prop)) { validators[prop] = [schema[prop]]; }\r\n        });\r\n      break;\r\n    }\r\n  }\r\n  if (hasOwn(schema, 'enum')) { validators.enum = [schema.enum]; }\r\n  return validators;\r\n}\r\n\r\n/**\r\n * 'resolveSchemaReferences' function\r\n *\r\n * Find all $ref links in schema and save links and referenced schemas in\r\n * schemaRefLibrary, schemaRecursiveRefMap, and dataRecursiveRefMap\r\n *\r\n * //  schema\r\n * //  schemaRefLibrary\r\n * // { Map<string, string> } schemaRecursiveRefMap\r\n * // { Map<string, string> } dataRecursiveRefMap\r\n * // { Map<string, number> } arrayMap\r\n * //\r\n */\r\nexport function resolveSchemaReferences(\r\n  schema, schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, arrayMap\r\n) {\r\n  if (!isObject(schema)) {\r\n    console.error('resolveSchemaReferences error: schema must be an object.');\r\n    return;\r\n  }\r\n  const refLinks = new Set<string>();\r\n  const refMapSet = new Set<string>();\r\n  const refMap = new Map<string, string>();\r\n  const recursiveRefMap = new Map<string, string>();\r\n  const refLibrary: any = {};\r\n\r\n  // Search schema for all $ref links, and build full refLibrary\r\n  JsonPointer.forEachDeep(schema, (subSchema, subSchemaPointer) => {\r\n    if (hasOwn(subSchema, '$ref') && isString(subSchema['$ref'])) {\r\n      const refPointer = JsonPointer.compile(subSchema['$ref']);\r\n      refLinks.add(refPointer);\r\n      refMapSet.add(subSchemaPointer + '~~' + refPointer);\r\n      refMap.set(subSchemaPointer, refPointer);\r\n    }\r\n  });\r\n  refLinks.forEach(ref => refLibrary[ref] = getSubSchema(schema, ref));\r\n\r\n  // Follow all ref links and save in refMapSet,\r\n  // to find any multi-link recursive refernces\r\n  let checkRefLinks = true;\r\n  while (checkRefLinks) {\r\n    checkRefLinks = false;\r\n    Array.from(refMap).forEach(([fromRef1, toRef1]) => Array.from(refMap)\r\n      .filter(([fromRef2, toRef2]) =>\r\n        JsonPointer.isSubPointer(toRef1, fromRef2, true) &&\r\n        !JsonPointer.isSubPointer(toRef2, toRef1, true) &&\r\n        !refMapSet.has(fromRef1 + fromRef2.slice(toRef1.length) + '~~' + toRef2)\r\n      )\r\n      .forEach(([fromRef2, toRef2]) => {\r\n        refMapSet.add(fromRef1 + fromRef2.slice(toRef1.length) + '~~' + toRef2);\r\n        checkRefLinks = true;\r\n      })\r\n    );\r\n  }\r\n\r\n  // Build full recursiveRefMap\r\n  // First pass - save all internally recursive refs from refMapSet\r\n  Array.from(refMapSet)\r\n    .map(refLink => refLink.split('~~'))\r\n    .filter(([fromRef, toRef]) => JsonPointer.isSubPointer(toRef, fromRef))\r\n    .forEach(([fromRef, toRef]) => recursiveRefMap.set(fromRef, toRef));\r\n  // Second pass - create recursive versions of any other refs that link to recursive refs\r\n  Array.from(refMap)\r\n    .filter(([fromRef1, toRef1]) => Array.from(recursiveRefMap.keys())\r\n      .every(fromRef2 => !JsonPointer.isSubPointer(fromRef1, fromRef2, true))\r\n    )\r\n    .forEach(([fromRef1, toRef1]) => Array.from(recursiveRefMap)\r\n      .filter(([fromRef2, toRef2]) =>\r\n        !recursiveRefMap.has(fromRef1 + fromRef2.slice(toRef1.length)) &&\r\n        JsonPointer.isSubPointer(toRef1, fromRef2, true) &&\r\n        !JsonPointer.isSubPointer(toRef1, fromRef1, true)\r\n      )\r\n      .forEach(([fromRef2, toRef2]) => recursiveRefMap.set(\r\n        fromRef1 + fromRef2.slice(toRef1.length),\r\n        fromRef1 + toRef2.slice(toRef1.length)\r\n      ))\r\n    );\r\n\r\n  // Create compiled schema by replacing all non-recursive $ref links with\r\n  // thieir linked schemas and, where possible, combining schemas in allOf arrays.\r\n  let compiledSchema = { ...schema };\r\n  delete compiledSchema.definitions;\r\n  compiledSchema =\r\n    getSubSchema(compiledSchema, '', refLibrary, recursiveRefMap);\r\n\r\n  // Make sure all remaining schema $refs are recursive, and build final\r\n  // schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, & arrayMap\r\n  JsonPointer.forEachDeep(compiledSchema, (subSchema, subSchemaPointer) => {\r\n    if (isString(subSchema['$ref'])) {\r\n      let refPointer = JsonPointer.compile(subSchema['$ref']);\r\n      if (!JsonPointer.isSubPointer(refPointer, subSchemaPointer, true)) {\r\n        refPointer = removeRecursiveReferences(subSchemaPointer, recursiveRefMap);\r\n        JsonPointer.set(compiledSchema, subSchemaPointer, { $ref: `#${refPointer}` });\r\n      }\r\n      if (!hasOwn(schemaRefLibrary, 'refPointer')) {\r\n        schemaRefLibrary[refPointer] = !refPointer.length ? compiledSchema :\r\n          getSubSchema(compiledSchema, refPointer, schemaRefLibrary, recursiveRefMap);\r\n      }\r\n      if (!schemaRecursiveRefMap.has(subSchemaPointer)) {\r\n        schemaRecursiveRefMap.set(subSchemaPointer, refPointer);\r\n      }\r\n      const fromDataRef = JsonPointer.toDataPointer(subSchemaPointer, compiledSchema);\r\n      if (!dataRecursiveRefMap.has(fromDataRef)) {\r\n        const toDataRef = JsonPointer.toDataPointer(refPointer, compiledSchema);\r\n        dataRecursiveRefMap.set(fromDataRef, toDataRef);\r\n      }\r\n    }\r\n    if (subSchema.type === 'array' &&\r\n      (hasOwn(subSchema, 'items') || hasOwn(subSchema, 'additionalItems'))\r\n    ) {\r\n      const dataPointer = JsonPointer.toDataPointer(subSchemaPointer, compiledSchema);\r\n      if (!arrayMap.has(dataPointer)) {\r\n        const tupleItems = isArray(subSchema.items) ? subSchema.items.length : 0;\r\n        arrayMap.set(dataPointer, tupleItems);\r\n      }\r\n    }\r\n  }, true);\r\n  return compiledSchema;\r\n}\r\n\r\n/**\r\n * 'getSubSchema' function\r\n *\r\n * //   schema\r\n * //  { Pointer } pointer\r\n * //  { object } schemaRefLibrary\r\n * //  { Map<string, string> } schemaRecursiveRefMap\r\n * //  { string[] = [] } usedPointers\r\n * //\r\n */\r\nexport function getSubSchema(\r\n  schema, pointer, schemaRefLibrary = null,\r\n  schemaRecursiveRefMap: Map<string, string> = null, usedPointers: string[] = []\r\n) {\r\n  if (!schemaRefLibrary || !schemaRecursiveRefMap) {\r\n    return JsonPointer.getCopy(schema, pointer);\r\n  }\r\n  if (typeof pointer !== 'string') { pointer = JsonPointer.compile(pointer); }\r\n  usedPointers = [ ...usedPointers, pointer ];\r\n  let newSchema: any = null;\r\n  if (pointer === '') {\r\n    newSchema = cloneDeep(schema);\r\n  } else {\r\n    const shortPointer = removeRecursiveReferences(pointer, schemaRecursiveRefMap);\r\n    if (shortPointer !== pointer) { usedPointers = [ ...usedPointers, shortPointer ]; }\r\n    newSchema = JsonPointer.getFirstCopy([\r\n      [schemaRefLibrary, [shortPointer]],\r\n      [schema, pointer],\r\n      [schema, shortPointer]\r\n    ]);\r\n  }\r\n  return JsonPointer.forEachDeepCopy(newSchema, (subSchema, subPointer) => {\r\n    if (isObject(subSchema)) {\r\n\r\n      // Replace non-recursive $ref links with referenced schemas\r\n      if (isString(subSchema.$ref)) {\r\n        const refPointer = JsonPointer.compile(subSchema.$ref);\r\n        if (refPointer.length && usedPointers.every(ptr =>\r\n          !JsonPointer.isSubPointer(refPointer, ptr, true)\r\n        )) {\r\n          const refSchema = getSubSchema(\r\n            schema, refPointer, schemaRefLibrary, schemaRecursiveRefMap, usedPointers\r\n          );\r\n          if (Object.keys(subSchema).length === 1) {\r\n            return refSchema;\r\n          } else {\r\n            const extraKeys = { ...subSchema };\r\n            delete extraKeys.$ref;\r\n            return mergeSchemas(refSchema, extraKeys);\r\n          }\r\n        }\r\n      }\r\n\r\n      // TODO: Convert schemas with 'type' arrays to 'oneOf'\r\n\r\n      // Combine allOf subSchemas\r\n      if (isArray(subSchema.allOf)) { return combineAllOf(subSchema); }\r\n\r\n      // Fix incorrectly placed array object required lists\r\n      if (subSchema.type === 'array' && isArray(subSchema.required)) {\r\n        return fixRequiredArrayProperties(subSchema);\r\n      }\r\n    }\r\n    return subSchema;\r\n  }, true, <string>pointer);\r\n}\r\n\r\n/**\r\n * 'combineAllOf' function\r\n *\r\n * Attempt to convert an allOf schema object into\r\n * a non-allOf schema object with equivalent rules.\r\n *\r\n * //   schema - allOf schema object\r\n * //  - converted schema object\r\n */\r\nexport function combineAllOf(schema) {\r\n  if (!isObject(schema) || !isArray(schema.allOf)) { return schema; }\r\n  let mergedSchema = mergeSchemas(...schema.allOf);\r\n  if (Object.keys(schema).length > 1) {\r\n    const extraKeys = { ...schema };\r\n    delete extraKeys.allOf;\r\n    mergedSchema = mergeSchemas(mergedSchema, extraKeys);\r\n  }\r\n  return mergedSchema;\r\n}\r\n\r\n/**\r\n * 'fixRequiredArrayProperties' function\r\n *\r\n * Fixes an incorrectly placed required list inside an array schema, by moving\r\n * it into items.properties or additionalItems.properties, where it belongs.\r\n *\r\n * //   schema - allOf schema object\r\n * //  - converted schema object\r\n */\r\nexport function fixRequiredArrayProperties(schema) {\r\n  if (schema.type === 'array' && isArray(schema.required)) {\r\n    const itemsObject = hasOwn(schema.items, 'properties') ? 'items' :\r\n      hasOwn(schema.additionalItems, 'properties') ? 'additionalItems' : null;\r\n    if (itemsObject && !hasOwn(schema[itemsObject], 'required') && (\r\n      hasOwn(schema[itemsObject], 'additionalProperties') ||\r\n      schema.required.every(key => hasOwn(schema[itemsObject].properties, key))\r\n    )) {\r\n      schema = cloneDeep(schema);\r\n      schema[itemsObject].required = schema.required;\r\n      delete schema.required;\r\n    }\r\n  }\r\n  return schema;\r\n}\r\n"]}