@ng-formworks/core 17.2.7 → 17.4.0

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

@@ -0,0 +1,1154 @@
+import cloneDeep from 'lodash/cloneDeep';
+import _isArray from 'lodash/isArray';
+import _isPlainObject from 'lodash/isPlainObject';
+import uniqueId from 'lodash/uniqueId';
+import { checkInlineType, getFromSchema, getInputType, isInputRequired, removeRecursiveReferences, updateInputOptions } from './json-schema.functions';
+import { JsonPointer } from './jsonpointer.functions';
+import { copy, fixTitle, forEach, hasOwn } from './utility.functions';
+import { inArray, isArray, isDefined, isEmpty, isNumber, isObject, isString } from './validator.functions';
+/**
+ * Layout function library:
+ *
+ * buildLayout:            Builds a complete layout from an input layout and schema
+ *
+ * buildLayoutFromSchema:  Builds a complete layout entirely from an input schema
+ *
+ * mapLayout:
+ *
+ * getLayoutNode:
+ *
+ * buildTitleMap:
+ */
+/**
+ * 'buildLayout' function
+ *
+ * //   jsf
+ * //   widgetLibrary
+ * //
+ */
+export function buildLayout_original(jsf, widgetLibrary) {
+    let hasSubmitButton = !JsonPointer.get(jsf, '/formOptions/addSubmit');
+    const formLayout = mapLayout(jsf.layout, (layoutItem, index, layoutPointer) => {
+        const newNode = {
+            _id: uniqueId(),
+            options: {},
+        };
+        if (isObject(layoutItem)) {
+            Object.assign(newNode, layoutItem);
+            Object.keys(newNode)
+                .filter(option => !inArray(option, [
+                '_id', '$ref', 'arrayItem', 'arrayItemType', 'dataPointer', 'dataType',
+                'items', 'key', 'name', 'options', 'recursiveReference', 'type', 'widget'
+            ]))
+                .forEach(option => {
+                newNode.options[option] = newNode[option];
+                delete newNode[option];
+            });
+            if (!hasOwn(newNode, 'type') && isString(newNode.widget)) {
+                newNode.type = newNode.widget;
+                delete newNode.widget;
+            }
+            if (!hasOwn(newNode.options, 'title')) {
+                if (hasOwn(newNode.options, 'legend')) {
+                    newNode.options.title = newNode.options.legend;
+                    delete newNode.options.legend;
+                }
+            }
+            if (!hasOwn(newNode.options, 'validationMessages')) {
+                if (hasOwn(newNode.options, 'errorMessages')) {
+                    newNode.options.validationMessages = newNode.options.errorMessages;
+                    delete newNode.options.errorMessages;
+                    // Convert Angular Schema Form (AngularJS) 'validationMessage' to
+                    // Angular JSON Schema Form 'validationMessages'
+                    // TV4 codes from https://github.com/geraintluff/tv4/blob/master/source/api.js
+                }
+                else if (hasOwn(newNode.options, 'validationMessage')) {
+                    if (typeof newNode.options.validationMessage === 'string') {
+                        newNode.options.validationMessages = newNode.options.validationMessage;
+                    }
+                    else {
+                        newNode.options.validationMessages = {};
+                        Object.keys(newNode.options.validationMessage).forEach(key => {
+                            const code = key + '';
+                            const newKey = code === '0' ? 'type' :
+                                code === '1' ? 'enum' :
+                                    code === '100' ? 'multipleOf' :
+                                        code === '101' ? 'minimum' :
+                                            code === '102' ? 'exclusiveMinimum' :
+                                                code === '103' ? 'maximum' :
+                                                    code === '104' ? 'exclusiveMaximum' :
+                                                        code === '200' ? 'minLength' :
+                                                            code === '201' ? 'maxLength' :
+                                                                code === '202' ? 'pattern' :
+                                                                    code === '300' ? 'minProperties' :
+                                                                        code === '301' ? 'maxProperties' :
+                                                                            code === '302' ? 'required' :
+                                                                                code === '304' ? 'dependencies' :
+                                                                                    code === '400' ? 'minItems' :
+                                                                                        code === '401' ? 'maxItems' :
+                                                                                            code === '402' ? 'uniqueItems' :
+                                                                                                code === '500' ? 'format' : code + '';
+                            newNode.options.validationMessages[newKey] = newNode.options.validationMessage[key];
+                        });
+                    }
+                    delete newNode.options.validationMessage;
+                }
+            }
+        }
+        else if (JsonPointer.isJsonPointer(layoutItem)) {
+            newNode.dataPointer = layoutItem;
+        }
+        else if (isString(layoutItem)) {
+            newNode.key = layoutItem;
+        }
+        else {
+            console.error('buildLayout error: Form layout element not recognized:');
+            console.error(layoutItem);
+            return null;
+        }
+        let nodeSchema = null;
+        // If newNode does not have a dataPointer, try to find an equivalent
+        if (!hasOwn(newNode, 'dataPointer')) {
+            // If newNode has a key, change it to a dataPointer
+            if (hasOwn(newNode, 'key')) {
+                newNode.dataPointer = newNode.key === '*' ? newNode.key :
+                    JsonPointer.compile(JsonPointer.parseObjectPath(newNode.key), '-');
+                delete newNode.key;
+                // If newNode is an array, search for dataPointer in child nodes
+            }
+            else if (hasOwn(newNode, 'type') && newNode.type.slice(-5) === 'array') {
+                const findDataPointer = (items) => {
+                    if (items === null || typeof items !== 'object') {
+                        return;
+                    }
+                    if (hasOwn(items, 'dataPointer')) {
+                        return items.dataPointer;
+                    }
+                    if (isArray(items.items)) {
+                        for (const item of items.items) {
+                            if (hasOwn(item, 'dataPointer') && item.dataPointer.indexOf('/-') !== -1) {
+                                return item.dataPointer;
+                            }
+                            if (hasOwn(item, 'items')) {
+                                const searchItem = findDataPointer(item);
+                                if (searchItem) {
+                                    return searchItem;
+                                }
+                            }
+                        }
+                    }
+                };
+                const childDataPointer = findDataPointer(newNode);
+                if (childDataPointer) {
+                    newNode.dataPointer =
+                        childDataPointer.slice(0, childDataPointer.lastIndexOf('/-'));
+                }
+            }
+        }
+        if (hasOwn(newNode, 'dataPointer')) {
+            if (newNode.dataPointer === '*') {
+                return buildLayoutFromSchema(jsf, widgetLibrary, jsf.formValues);
+            }
+            const nodeValue = JsonPointer.get(jsf.formValues, newNode.dataPointer.replace(/\/-/g, '/1'));
+            // TODO: Create function getFormValues(jsf, dataPointer, forRefLibrary)
+            // check formOptions.setSchemaDefaults and formOptions.setLayoutDefaults
+            // then set apropriate values from initialVaues, schema, or layout
+            newNode.dataPointer =
+                JsonPointer.toGenericPointer(newNode.dataPointer, jsf.arrayMap);
+            const LastKey = JsonPointer.toKey(newNode.dataPointer);
+            if (!newNode.name && isString(LastKey) && LastKey !== '-') {
+                newNode.name = LastKey;
+            }
+            const shortDataPointer = removeRecursiveReferences(newNode.dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap);
+            const recursive = !shortDataPointer.length ||
+                shortDataPointer !== newNode.dataPointer;
+            let schemaPointer;
+            if (!jsf.dataMap.has(shortDataPointer)) {
+                jsf.dataMap.set(shortDataPointer, new Map());
+            }
+            const nodeDataMap = jsf.dataMap.get(shortDataPointer);
+            if (nodeDataMap.has('schemaPointer')) {
+                schemaPointer = nodeDataMap.get('schemaPointer');
+            }
+            else {
+                schemaPointer = JsonPointer.toSchemaPointer(shortDataPointer, jsf.schema);
+                nodeDataMap.set('schemaPointer', schemaPointer);
+            }
+            nodeDataMap.set('disabled', !!newNode.options.disabled);
+            nodeSchema = JsonPointer.get(jsf.schema, schemaPointer);
+            if (nodeSchema) {
+                if (!hasOwn(newNode, 'type')) {
+                    newNode.type = getInputType(nodeSchema, newNode);
+                }
+                else if (!widgetLibrary.hasWidget(newNode.type)) {
+                    const oldWidgetType = newNode.type;
+                    newNode.type = getInputType(nodeSchema, newNode);
+                    console.error(`error: widget type "${oldWidgetType}" ` +
+                        `not found in library. Replacing with "${newNode.type}".`);
+                }
+                else {
+                    newNode.type = checkInlineType(newNode.type, nodeSchema, newNode);
+                }
+                if (nodeSchema.type === 'object' && isArray(nodeSchema.required)) {
+                    nodeDataMap.set('required', nodeSchema.required);
+                }
+                newNode.dataType =
+                    nodeSchema.type || (hasOwn(nodeSchema, '$ref') ? '$ref' : null);
+                updateInputOptions(newNode, nodeSchema, jsf);
+                // Present checkboxes as single control, rather than array
+                if (newNode.type === 'checkboxes' && hasOwn(nodeSchema, 'items')) {
+                    updateInputOptions(newNode, nodeSchema.items, jsf);
+                }
+                else if (newNode.dataType === 'array') {
+                    newNode.options.maxItems = Math.min(nodeSchema.maxItems || 1000, newNode.options.maxItems || 1000);
+                    newNode.options.minItems = Math.max(nodeSchema.minItems || 0, newNode.options.minItems || 0);
+                    newNode.options.listItems = Math.max(newNode.options.listItems || 0, isArray(nodeValue) ? nodeValue.length : 0);
+                    newNode.options.tupleItems =
+                        isArray(nodeSchema.items) ? nodeSchema.items.length : 0;
+                    if (newNode.options.maxItems < newNode.options.tupleItems) {
+                        newNode.options.tupleItems = newNode.options.maxItems;
+                        newNode.options.listItems = 0;
+                    }
+                    else if (newNode.options.maxItems <
+                        newNode.options.tupleItems + newNode.options.listItems) {
+                        newNode.options.listItems =
+                            newNode.options.maxItems - newNode.options.tupleItems;
+                    }
+                    else if (newNode.options.minItems >
+                        newNode.options.tupleItems + newNode.options.listItems) {
+                        newNode.options.listItems =
+                            newNode.options.minItems - newNode.options.tupleItems;
+                    }
+                    if (!nodeDataMap.has('maxItems')) {
+                        nodeDataMap.set('maxItems', newNode.options.maxItems);
+                        nodeDataMap.set('minItems', newNode.options.minItems);
+                        nodeDataMap.set('tupleItems', newNode.options.tupleItems);
+                        nodeDataMap.set('listItems', newNode.options.listItems);
+                    }
+                    if (!jsf.arrayMap.has(shortDataPointer)) {
+                        jsf.arrayMap.set(shortDataPointer, newNode.options.tupleItems);
+                    }
+                }
+                if (isInputRequired(jsf.schema, schemaPointer)) {
+                    newNode.options.required = true;
+                    jsf.fieldsRequired = true;
+                }
+            }
+            else {
+                // TODO: create item in FormGroup model from layout key (?)
+                updateInputOptions(newNode, {}, jsf);
+            }
+            if (!newNode.options.title && !/^\d+$/.test(newNode.name)) {
+                newNode.options.title = fixTitle(newNode.name);
+            }
+            if (hasOwn(newNode.options, 'copyValueTo')) {
+                if (typeof newNode.options.copyValueTo === 'string') {
+                    newNode.options.copyValueTo = [newNode.options.copyValueTo];
+                }
+                if (isArray(newNode.options.copyValueTo)) {
+                    newNode.options.copyValueTo = newNode.options.copyValueTo.map(item => JsonPointer.compile(JsonPointer.parseObjectPath(item), '-'));
+                }
+            }
+            newNode.widget = widgetLibrary.getWidget(newNode.type);
+            nodeDataMap.set('inputType', newNode.type);
+            nodeDataMap.set('widget', newNode.widget);
+            if (newNode.dataType === 'array' &&
+                (hasOwn(newNode, 'items') || hasOwn(newNode, 'additionalItems'))) {
+                const itemRefPointer = removeRecursiveReferences(newNode.dataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap);
+                if (!jsf.dataMap.has(itemRefPointer)) {
+                    jsf.dataMap.set(itemRefPointer, new Map());
+                }
+                jsf.dataMap.get(itemRefPointer).set('inputType', 'section');
+                // Fix insufficiently nested array item groups
+                if (newNode.items.length > 1) {
+                    const arrayItemGroup = [];
+                    for (let i = newNode.items.length - 1; i >= 0; i--) {
+                        const subItem = newNode.items[i];
+                        if (hasOwn(subItem, 'dataPointer') &&
+                            subItem.dataPointer.slice(0, itemRefPointer.length) === itemRefPointer) {
+                            const arrayItem = newNode.items.splice(i, 1)[0];
+                            arrayItem.dataPointer = newNode.dataPointer + '/-' +
+                                arrayItem.dataPointer.slice(itemRefPointer.length);
+                            arrayItemGroup.unshift(arrayItem);
+                        }
+                        else {
+                            subItem.arrayItem = true;
+                            // TODO: Check schema to get arrayItemType and removable
+                            subItem.arrayItemType = 'list';
+                            subItem.removable = newNode.options.removable !== false;
+                        }
+                    }
+                    if (arrayItemGroup.length) {
+                        newNode.items.push({
+                            _id: uniqueId(),
+                            arrayItem: true,
+                            arrayItemType: newNode.options.tupleItems > newNode.items.length ?
+                                'tuple' : 'list',
+                            items: arrayItemGroup,
+                            options: { removable: newNode.options.removable !== false, },
+                            dataPointer: newNode.dataPointer + '/-',
+                            type: 'section',
+                            widget: widgetLibrary.getWidget('section'),
+                        });
+                    }
+                }
+                else {
+                    // TODO: Fix to hndle multiple items
+                    newNode.items[0].arrayItem = true;
+                    if (!newNode.items[0].dataPointer) {
+                        newNode.items[0].dataPointer =
+                            JsonPointer.toGenericPointer(itemRefPointer, jsf.arrayMap);
+                    }
+                    if (!JsonPointer.has(newNode, '/items/0/options/removable')) {
+                        newNode.items[0].options.removable = true;
+                    }
+                    if (newNode.options.orderable === false) {
+                        newNode.items[0].options.orderable = false;
+                    }
+                    newNode.items[0].arrayItemType =
+                        newNode.options.tupleItems ? 'tuple' : 'list';
+                }
+                if (isArray(newNode.items)) {
+                    const arrayListItems = newNode.items.filter(item => item.type !== '$ref').length -
+                        newNode.options.tupleItems;
+                    if (arrayListItems > newNode.options.listItems) {
+                        newNode.options.listItems = arrayListItems;
+                        nodeDataMap.set('listItems', arrayListItems);
+                    }
+                }
+                if (!hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {
+                    jsf.layoutRefLibrary[itemRefPointer] =
+                        cloneDeep(newNode.items[newNode.items.length - 1]);
+                    if (recursive) {
+                        jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;
+                    }
+                    forEach(jsf.layoutRefLibrary[itemRefPointer], (item, key) => {
+                        if (hasOwn(item, '_id')) {
+                            item._id = null;
+                        }
+                        if (recursive) {
+                            if (hasOwn(item, 'dataPointer')) {
+                                item.dataPointer = item.dataPointer.slice(itemRefPointer.length);
+                            }
+                        }
+                    }, 'top-down');
+                }
+                // Add any additional default items
+                if (!newNode.recursiveReference || newNode.options.required) {
+                    const arrayLength = Math.min(Math.max(newNode.options.tupleItems + newNode.options.listItems, isArray(nodeValue) ? nodeValue.length : 0), newNode.options.maxItems);
+                    for (let i = newNode.items.length; i < arrayLength; i++) {
+                        newNode.items.push(getLayoutNode({
+                            $ref: itemRefPointer,
+                            dataPointer: newNode.dataPointer,
+                            recursiveReference: newNode.recursiveReference,
+                        }, jsf, widgetLibrary));
+                    }
+                }
+                // If needed, add button to add items to array
+                if (newNode.options.addable !== false &&
+                    newNode.options.minItems < newNode.options.maxItems &&
+                    (newNode.items[newNode.items.length - 1] || {}).type !== '$ref') {
+                    let buttonText = 'Add';
+                    if (newNode.options.title) {
+                        if (/^add\b/i.test(newNode.options.title)) {
+                            buttonText = newNode.options.title;
+                        }
+                        else {
+                            buttonText += ' ' + newNode.options.title;
+                        }
+                    }
+                    else if (newNode.name && !/^\d+$/.test(newNode.name)) {
+                        if (/^add\b/i.test(newNode.name)) {
+                            buttonText += ' ' + fixTitle(newNode.name);
+                        }
+                        else {
+                            buttonText = fixTitle(newNode.name);
+                        }
+                        // If newNode doesn't have a title, look for title of parent array item
+                    }
+                    else {
+                        const parentSchema = getFromSchema(jsf.schema, newNode.dataPointer, 'parentSchema');
+                        if (hasOwn(parentSchema, 'title')) {
+                            buttonText += ' to ' + parentSchema.title;
+                        }
+                        else {
+                            const pointerArray = JsonPointer.parse(newNode.dataPointer);
+                            buttonText += ' to ' + fixTitle(pointerArray[pointerArray.length - 2]);
+                        }
+                    }
+                    newNode.items.push({
+                        _id: uniqueId(),
+                        arrayItem: true,
+                        arrayItemType: 'list',
+                        dataPointer: newNode.dataPointer + '/-',
+                        options: {
+                            listItems: newNode.options.listItems,
+                            maxItems: newNode.options.maxItems,
+                            minItems: newNode.options.minItems,
+                            removable: false,
+                            title: buttonText,
+                            tupleItems: newNode.options.tupleItems,
+                        },
+                        recursiveReference: recursive,
+                        type: '$ref',
+                        widget: widgetLibrary.getWidget('$ref'),
+                        $ref: itemRefPointer,
+                    });
+                    if (isString(JsonPointer.get(newNode, '/style/add'))) {
+                        newNode.items[newNode.items.length - 1].options.fieldStyle =
+                            newNode.style.add;
+                        delete newNode.style.add;
+                        if (isEmpty(newNode.style)) {
+                            delete newNode.style;
+                        }
+                    }
+                }
+            }
+            else {
+                newNode.arrayItem = false;
+            }
+        }
+        else if (hasOwn(newNode, 'type') || hasOwn(newNode, 'items')) {
+            const parentType = JsonPointer.get(jsf.layout, layoutPointer, 0, -2).type;
+            if (!hasOwn(newNode, 'type')) {
+                newNode.type =
+                    inArray(parentType, ['tabs', 'tabarray']) ? 'tab' : 'array';
+            }
+            newNode.arrayItem = parentType === 'array';
+            newNode.widget = widgetLibrary.getWidget(newNode.type);
+            updateInputOptions(newNode, {}, jsf);
+        }
+        if (newNode.type === 'submit') {
+            hasSubmitButton = true;
+        }
+        return newNode;
+    });
+    if (jsf.hasRootReference) {
+        const fullLayout = cloneDeep(formLayout);
+        if (fullLayout[fullLayout.length - 1].type === 'submit') {
+            fullLayout.pop();
+        }
+        jsf.layoutRefLibrary[''] = {
+            _id: null,
+            dataPointer: '',
+            dataType: 'object',
+            items: fullLayout,
+            name: '',
+            options: cloneDeep(jsf.formOptions.defaultWidgetOptions),
+            recursiveReference: true,
+            required: false,
+            type: 'section',
+            widget: widgetLibrary.getWidget('section'),
+        };
+    }
+    if (!hasSubmitButton) {
+        formLayout.push({
+            _id: uniqueId(),
+            options: { title: 'Submit' },
+            type: 'submit',
+            widget: widgetLibrary.getWidget('submit'),
+        });
+    }
+    return formLayout;
+}
+//TODO-review:this implements a quick 'post' fix rather than an
+//integrared ideal fix
+export function buildLayout(jsf, widgetLibrary) {
+    let layout = buildLayout_original(jsf, widgetLibrary);
+    if (jsf.formValues) {
+        let fixedLayout = fixNestedArrayLayout({
+            builtLayout: layout,
+            formData: jsf.formValues
+        });
+    }
+    return layout;
+}
+function fixNestedArrayLayout(options) {
+    let { builtLayout, formData } = options;
+    let arrLengths = {};
+    let traverseObj = function (obj, path, onValue) {
+        if (_isArray(obj)) {
+            onValue && onValue(obj, path);
+            obj.forEach((item, ind) => {
+                onValue && onValue(item, path + "/" + ind);
+                traverseObj(item, path + "/" + ind, onValue);
+            });
+            return;
+        }
+        if (_isPlainObject(obj)) {
+            onValue && onValue(obj, path);
+            Object.keys(obj).forEach(key => {
+                onValue && onValue(obj[key], path + "/" + key);
+                traverseObj(obj[key], path + "/" + key, onValue);
+            });
+            return;
+        }
+    };
+    traverseObj(formData, "", (value, path) => {
+        if (_isArray(value)) {
+            arrLengths[path] = arrLengths[path] || value.length;
+        }
+    });
+    let getDataSize = (options) => {
+        let { data, dataPointer, indexArray } = options;
+        let dashCount = 0;
+        let dpInstance = dataPointer.substring(1).split("/").map((part, pind) => {
+            if (part == "-" && indexArray[dashCount] != undefined) {
+                return indexArray[dashCount++];
+            }
+            return part;
+        })
+            .join("/");
+        dpInstance = "/" + dpInstance;
+        let arrSize = arrLengths[dpInstance];
+        return arrSize;
+    };
+    //still too buggy
+    let createNonRefItem = (nodeWithRef) => {
+        let templateNode = {
+            "type": "section",
+            "recursiveReference": false,
+            "items": []
+        };
+        let clone = cloneDeep(nodeWithRef);
+        //commented out for now so that it behaves as ususal
+        //_.merge(clone,templateNode);
+        return clone;
+    };
+    let rebuildLayout = (options) => {
+        let { builtLayout, indices, parentDataPointer, indexPos } = options;
+        indices = indices || [];
+        indexPos = indexPos == undefined ? indexPos = -1 : indexPos;
+        if (_isArray(builtLayout)) {
+            builtLayout.forEach((item, index) => {
+                rebuildLayout({
+                    builtLayout: item,
+                    indices: indices,
+                    indexPos: indexPos,
+                    parentDataPointer: builtLayout.dataPointer || parentDataPointer
+                });
+            });
+            return;
+        }
+        let dataTypes = ["array"]; //check only array for now
+        //for now added condition to ignore recursive references
+        if (builtLayout.items && dataTypes.indexOf(builtLayout.dataType) >= 0
+            && builtLayout.dataPointer
+            && !builtLayout.recursiveReference) {
+            let numDataItems = getDataSize({
+                data: formData,
+                dataPointer: builtLayout.dataPointer,
+                indexArray: indices
+            });
+            let numActualItems = builtLayout.items.length;
+            //check if there's ref items, if so ignore it and therefore
+            //decrement the item count
+            builtLayout.items.forEach(item => {
+                if (item.type && item.type == "$ref") {
+                    numActualItems--;
+                }
+            });
+            numActualItems = Math.max(numActualItems, 0); //avoid dealing with negatives
+            if (numActualItems < numDataItems) {
+                let numItemsNeeded = numDataItems - numActualItems;
+                //added to ignore recursive references
+                if (numActualItems == 0 && builtLayout.items[0].recursiveReference) {
+                    numItemsNeeded = 0;
+                }
+                for (let i = 0; i < numItemsNeeded; i++) {
+                    //node must not be of type "type": "$ref"
+                    //if it is then manufacture our own
+                    let isRefNode = builtLayout.items[0].type && builtLayout.items[0].type == "$ref";
+                    let newItem = isRefNode
+                        ? createNonRefItem(builtLayout.items[0])
+                        : cloneDeep(builtLayout.items[0]); //copy first
+                    newItem._id = uniqueId("new_");
+                    builtLayout.items.unshift(newItem);
+                }
+                if (builtLayout.options.listItems) {
+                    builtLayout.options.listItems = numDataItems;
+                }
+            }
+            indices[builtLayout.dataPointer] = indices[builtLayout.dataPointer] || -1;
+            indexPos++;
+            builtLayout.items.forEach((item, index) => {
+                indices[indexPos] = index;
+                rebuildLayout({
+                    builtLayout: item,
+                    indices: indices,
+                    parentDataPointer: builtLayout.dataPointer,
+                    indexPos: indexPos
+                });
+            });
+            indexPos--;
+        }
+        else {
+            if (builtLayout.items) {
+                builtLayout.items.forEach((item, index) => {
+                    rebuildLayout({
+                        builtLayout: item,
+                        indices: indices,
+                        parentDataPointer: parentDataPointer,
+                        indexPos: indexPos
+                    });
+                });
+            }
+        }
+    };
+    rebuildLayout({
+        builtLayout: builtLayout
+    });
+    //NB original is mutated
+    let fixedLayout = builtLayout;
+    return fixedLayout;
+}
+/**
+ * 'buildLayoutFromSchema' function
+ *
+ * //   jsf -
+ * //   widgetLibrary -
+ * //   nodeValue -
+ * //  { string = '' } schemaPointer -
+ * //  { string = '' } dataPointer -
+ * //  { boolean = false } arrayItem -
+ * //  { string = null } arrayItemType -
+ * //  { boolean = null } removable -
+ * //  { boolean = false } forRefLibrary -
+ * //  { string = '' } dataPointerPrefix -
+ * //
+ */
+export function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPointer = '', dataPointer = '', arrayItem = false, arrayItemType = null, removable = null, forRefLibrary = false, dataPointerPrefix = '') {
+    const schema = JsonPointer.get(jsf.schema, schemaPointer);
+    if (!hasOwn(schema, 'type') && !hasOwn(schema, '$ref') &&
+        !hasOwn(schema, 'x-schema-form')) {
+        return null;
+    }
+    const newNodeType = getInputType(schema);
+    if (!isDefined(nodeValue) && (jsf.formOptions.setSchemaDefaults === true ||
+        (jsf.formOptions.setSchemaDefaults === 'auto' && isEmpty(jsf.formValues)))) {
+        nodeValue = JsonPointer.get(jsf.schema, schemaPointer + '/default');
+    }
+    let newNode = {
+        _id: forRefLibrary ? null : uniqueId(),
+        arrayItem: arrayItem,
+        dataPointer: JsonPointer.toGenericPointer(dataPointer, jsf.arrayMap),
+        dataType: schema.type || (hasOwn(schema, '$ref') ? '$ref' : null),
+        options: {},
+        required: isInputRequired(jsf.schema, schemaPointer),
+        type: newNodeType,
+        widget: widgetLibrary.getWidget(newNodeType),
+    };
+    const lastDataKey = JsonPointer.toKey(newNode.dataPointer);
+    if (lastDataKey !== '-') {
+        newNode.name = lastDataKey;
+    }
+    if (newNode.arrayItem) {
+        newNode.arrayItemType = arrayItemType;
+        newNode.options.removable = removable !== false;
+    }
+    const shortDataPointer = removeRecursiveReferences(dataPointerPrefix + dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap);
+    const recursive = !shortDataPointer.length ||
+        shortDataPointer !== dataPointerPrefix + dataPointer;
+    if (!jsf.dataMap.has(shortDataPointer)) {
+        jsf.dataMap.set(shortDataPointer, new Map());
+    }
+    const nodeDataMap = jsf.dataMap.get(shortDataPointer);
+    if (!nodeDataMap.has('inputType')) {
+        nodeDataMap.set('schemaPointer', schemaPointer);
+        nodeDataMap.set('inputType', newNode.type);
+        nodeDataMap.set('widget', newNode.widget);
+        nodeDataMap.set('disabled', !!newNode.options.disabled);
+    }
+    updateInputOptions(newNode, schema, jsf);
+    if (!newNode.options.title && newNode.name && !/^\d+$/.test(newNode.name)) {
+        newNode.options.title = fixTitle(newNode.name);
+    }
+    if (newNode.dataType === 'object') {
+        if (isArray(schema.required) && !nodeDataMap.has('required')) {
+            nodeDataMap.set('required', schema.required);
+        }
+        if (isObject(schema.properties)) {
+            const newSection = [];
+            const propertyKeys = schema['ui:order'] || Object.keys(schema.properties);
+            if (propertyKeys.includes('*') && !hasOwn(schema.properties, '*')) {
+                const unnamedKeys = Object.keys(schema.properties)
+                    .filter(key => !propertyKeys.includes(key));
+                for (let i = propertyKeys.length - 1; i >= 0; i--) {
+                    if (propertyKeys[i] === '*') {
+                        propertyKeys.splice(i, 1, ...unnamedKeys);
+                    }
+                }
+            }
+            propertyKeys
+                .filter(key => hasOwn(schema.properties, key) ||
+                hasOwn(schema, 'additionalProperties'))
+                .forEach(key => {
+                const keySchemaPointer = hasOwn(schema.properties, key) ?
+                    '/properties/' + key : '/additionalProperties';
+                const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, isObject(nodeValue) ? nodeValue[key] : null, schemaPointer + keySchemaPointer, dataPointer + '/' + key, false, null, null, forRefLibrary, dataPointerPrefix);
+                if (innerItem) {
+                    if (isInputRequired(schema, '/' + key)) {
+                        innerItem.options.required = true;
+                        jsf.fieldsRequired = true;
+                    }
+                    newSection.push(innerItem);
+                }
+            });
+            if (dataPointer === '' && !forRefLibrary) {
+                newNode = newSection;
+            }
+            else {
+                newNode.items = newSection;
+            }
+        }
+        // TODO: Add patternProperties and additionalProperties inputs?
+        // ... possibly provide a way to enter both key names and values?
+        // if (isObject(schema.patternProperties)) { }
+        // if (isObject(schema.additionalProperties)) { }
+    }
+    else if (newNode.dataType === 'array') {
+        newNode.items = [];
+        newNode.options.maxItems = Math.min(schema.maxItems || 1000, newNode.options.maxItems || 1000);
+        newNode.options.minItems = Math.max(schema.minItems || 0, newNode.options.minItems || 0);
+        if (!newNode.options.minItems && isInputRequired(jsf.schema, schemaPointer)) {
+            newNode.options.minItems = 1;
+        }
+        if (!hasOwn(newNode.options, 'listItems')) {
+            newNode.options.listItems = 1;
+        }
+        newNode.options.tupleItems = isArray(schema.items) ? schema.items.length : 0;
+        if (newNode.options.maxItems <= newNode.options.tupleItems) {
+            newNode.options.tupleItems = newNode.options.maxItems;
+            newNode.options.listItems = 0;
+        }
+        else if (newNode.options.maxItems <
+            newNode.options.tupleItems + newNode.options.listItems) {
+            newNode.options.listItems = newNode.options.maxItems - newNode.options.tupleItems;
+        }
+        else if (newNode.options.minItems >
+            newNode.options.tupleItems + newNode.options.listItems) {
+            newNode.options.listItems = newNode.options.minItems - newNode.options.tupleItems;
+        }
+        if (!nodeDataMap.has('maxItems')) {
+            nodeDataMap.set('maxItems', newNode.options.maxItems);
+            nodeDataMap.set('minItems', newNode.options.minItems);
+            nodeDataMap.set('tupleItems', newNode.options.tupleItems);
+            nodeDataMap.set('listItems', newNode.options.listItems);
+        }
+        if (!jsf.arrayMap.has(shortDataPointer)) {
+            jsf.arrayMap.set(shortDataPointer, newNode.options.tupleItems);
+        }
+        removable = newNode.options.removable !== false;
+        let additionalItemsSchemaPointer = null;
+        // If 'items' is an array = tuple items
+        if (isArray(schema.items)) {
+            newNode.items = [];
+            for (let i = 0; i < newNode.options.tupleItems; i++) {
+                let newItem;
+                const itemRefPointer = removeRecursiveReferences(shortDataPointer + '/' + i, jsf.dataRecursiveRefMap, jsf.arrayMap);
+                const itemRecursive = !itemRefPointer.length ||
+                    itemRefPointer !== shortDataPointer + '/' + i;
+                // If removable, add tuple item layout to layoutRefLibrary
+                if (removable && i >= newNode.options.minItems) {
+                    if (!hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {
+                        // Set to null first to prevent recursive reference from causing endless loop
+                        jsf.layoutRefLibrary[itemRefPointer] = null;
+                        jsf.layoutRefLibrary[itemRefPointer] = buildLayoutFromSchema(jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null, schemaPointer + '/items/' + i, itemRecursive ? '' : dataPointer + '/' + i, true, 'tuple', true, true, itemRecursive ? dataPointer + '/' + i : '');
+                        if (itemRecursive) {
+                            jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;
+                        }
+                    }
+                    newItem = getLayoutNode({
+                        $ref: itemRefPointer,
+                        dataPointer: dataPointer + '/' + i,
+                        recursiveReference: itemRecursive,
+                    }, jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null);
+                }
+                else {
+                    newItem = buildLayoutFromSchema(jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null, schemaPointer + '/items/' + i, dataPointer + '/' + i, true, 'tuple', false, forRefLibrary, dataPointerPrefix);
+                }
+                if (newItem) {
+                    newNode.items.push(newItem);
+                }
+            }
+            // If 'additionalItems' is an object = additional list items, after tuple items
+            if (isObject(schema.additionalItems)) {
+                additionalItemsSchemaPointer = schemaPointer + '/additionalItems';
+            }
+            // If 'items' is an object = list items only (no tuple items)
+        }
+        else if (isObject(schema.items)) {
+            additionalItemsSchemaPointer = schemaPointer + '/items';
+        }
+        if (additionalItemsSchemaPointer) {
+            const itemRefPointer = removeRecursiveReferences(shortDataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap);
+            const itemRecursive = !itemRefPointer.length ||
+                itemRefPointer !== shortDataPointer + '/-';
+            const itemSchemaPointer = removeRecursiveReferences(additionalItemsSchemaPointer, jsf.schemaRecursiveRefMap, jsf.arrayMap);
+            // Add list item layout to layoutRefLibrary
+            if (itemRefPointer.length && !hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {
+                // Set to null first to prevent recursive reference from causing endless loop
+                jsf.layoutRefLibrary[itemRefPointer] = null;
+                jsf.layoutRefLibrary[itemRefPointer] = buildLayoutFromSchema(jsf, widgetLibrary, null, itemSchemaPointer, itemRecursive ? '' : dataPointer + '/-', true, 'list', removable, true, itemRecursive ? dataPointer + '/-' : '');
+                if (itemRecursive) {
+                    jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;
+                }
+            }
+            // Add any additional default items
+            if (!itemRecursive || newNode.options.required) {
+                const arrayLength = Math.min(Math.max(itemRecursive ? 0 :
+                    newNode.options.tupleItems + newNode.options.listItems, isArray(nodeValue) ? nodeValue.length : 0), newNode.options.maxItems);
+                if (newNode.items.length < arrayLength) {
+                    for (let i = newNode.items.length; i < arrayLength; i++) {
+                        newNode.items.push(getLayoutNode({
+                            $ref: itemRefPointer,
+                            dataPointer: dataPointer + '/-',
+                            recursiveReference: itemRecursive,
+                        }, jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null));
+                    }
+                }
+            }
+            // If needed, add button to add items to array
+            if (newNode.options.addable !== false &&
+                newNode.options.minItems < newNode.options.maxItems &&
+                (newNode.items[newNode.items.length - 1] || {}).type !== '$ref') {
+                let buttonText = ((jsf.layoutRefLibrary[itemRefPointer] || {}).options || {}).title;
+                const prefix = buttonText ? 'Add ' : 'Add to ';
+                if (!buttonText) {
+                    buttonText = schema.title || fixTitle(JsonPointer.toKey(dataPointer));
+                }
+                if (!/^add\b/i.test(buttonText)) {
+                    buttonText = prefix + buttonText;
+                }
+                newNode.items.push({
+                    _id: uniqueId(),
+                    arrayItem: true,
+                    arrayItemType: 'list',
+                    dataPointer: newNode.dataPointer + '/-',
+                    options: {
+                        listItems: newNode.options.listItems,
+                        maxItems: newNode.options.maxItems,
+                        minItems: newNode.options.minItems,
+                        removable: false,
+                        title: buttonText,
+                        tupleItems: newNode.options.tupleItems,
+                    },
+                    recursiveReference: itemRecursive,
+                    type: '$ref',
+                    widget: widgetLibrary.getWidget('$ref'),
+                    $ref: itemRefPointer,
+                });
+            }
+        }
+    }
+    else if (newNode.dataType === '$ref') {
+        const schemaRef = JsonPointer.compile(schema.$ref);
+        const dataRef = JsonPointer.toDataPointer(schemaRef, jsf.schema);
+        let buttonText = '';
+        // Get newNode title
+        if (newNode.options.add) {
+            buttonText = newNode.options.add;
+        }
+        else if (newNode.name && !/^\d+$/.test(newNode.name)) {
+            buttonText =
+                (/^add\b/i.test(newNode.name) ? '' : 'Add ') + fixTitle(newNode.name);
+            // If newNode doesn't have a title, look for title of parent array item
+        }
+        else {
+            const parentSchema = JsonPointer.get(jsf.schema, schemaPointer, 0, -1);
+            if (hasOwn(parentSchema, 'title')) {
+                buttonText = 'Add to ' + parentSchema.title;
+            }
+            else {
+                const pointerArray = JsonPointer.parse(newNode.dataPointer);
+                buttonText = 'Add to ' + fixTitle(pointerArray[pointerArray.length - 2]);
+            }
+        }
+        Object.assign(newNode, {
+            recursiveReference: true,
+            widget: widgetLibrary.getWidget('$ref'),
+            $ref: dataRef,
+        });
+        Object.assign(newNode.options, {
+            removable: false,
+            title: buttonText,
+        });
+        if (isNumber(JsonPointer.get(jsf.schema, schemaPointer, 0, -1).maxItems)) {
+            newNode.options.maxItems =
+                JsonPointer.get(jsf.schema, schemaPointer, 0, -1).maxItems;
+        }
+        // Add layout template to layoutRefLibrary
+        if (dataRef.length) {
+            if (!hasOwn(jsf.layoutRefLibrary, dataRef)) {
+                // Set to null first to prevent recursive reference from causing endless loop
+                jsf.layoutRefLibrary[dataRef] = null;
+                const newLayout = buildLayoutFromSchema(jsf, widgetLibrary, null, schemaRef, '', newNode.arrayItem, newNode.arrayItemType, true, true, dataPointer);
+                if (newLayout) {
+                    newLayout.recursiveReference = true;
+                    jsf.layoutRefLibrary[dataRef] = newLayout;
+                }
+                else {
+                    delete jsf.layoutRefLibrary[dataRef];
+                }
+            }
+            else if (!jsf.layoutRefLibrary[dataRef].recursiveReference) {
+                jsf.layoutRefLibrary[dataRef].recursiveReference = true;
+            }
+        }
+    }
+    return newNode;
+}
+/**
+ * 'mapLayout' function
+ *
+ * Creates a new layout by running each element in an existing layout through
+ * an iteratee. Recursively maps within array elements 'items' and 'tabs'.
+ * The iteratee is invoked with four arguments: (value, index, layout, path)
+ *
+ * The returned layout may be longer (or shorter) then the source layout.
+ *
+ * If an item from the source layout returns multiple items (as '*' usually will),
+ * this function will keep all returned items in-line with the surrounding items.
+ *
+ * If an item from the source layout causes an error and returns null, it is
+ * skipped without error, and the function will still return all non-null items.
+ *
+ * //   layout - the layout to map
+ * //  { (v: any, i?: number, l?: any, p?: string) => any }
+ *   function - the funciton to invoke on each element
+ * //  { string|string[] = '' } layoutPointer - the layoutPointer to layout, inside rootLayout
+ * //  { any[] = layout } rootLayout - the root layout, which conatins layout
+ * //
+ */
+export function mapLayout(layout, fn, layoutPointer = '', rootLayout = layout) {
+    let indexPad = 0;
+    let newLayout = [];
+    forEach(layout, (item, index) => {
+        const realIndex = +index + indexPad;
+        const newLayoutPointer = layoutPointer + '/' + realIndex;
+        let newNode = copy(item);
+        let itemsArray = [];
+        if (isObject(item)) {
+            if (hasOwn(item, 'tabs')) {
+                item.items = item.tabs;
+                delete item.tabs;
+            }
+            if (hasOwn(item, 'items')) {
+                itemsArray = isArray(item.items) ? item.items : [item.items];
+            }
+        }
+        if (itemsArray.length) {
+            newNode.items = mapLayout(itemsArray, fn, newLayoutPointer + '/items', rootLayout);
+        }
+        newNode = fn(newNode, realIndex, newLayoutPointer, rootLayout);
+        if (!isDefined(newNode)) {
+            indexPad--;
+        }
+        else {
+            if (isArray(newNode)) {
+                indexPad += newNode.length - 1;
+            }
+            newLayout = newLayout.concat(newNode);
+        }
+    });
+    return newLayout;
+}
+/**
+ * 'getLayoutNode' function
+ * Copy a new layoutNode from layoutRefLibrary
+ *
+ * //   refNode -
+ * //   layoutRefLibrary -
+ * //  { any = null } widgetLibrary -
+ * //  { any = null } nodeValue -
+ * //  copied layoutNode
+ */
+export function getLayoutNode(refNode, jsf, widgetLibrary = null, nodeValue = null) {
+    // If recursive reference and building initial layout, return Add button
+    if (refNode.recursiveReference && widgetLibrary) {
+        const newLayoutNode = cloneDeep(refNode);
+        if (!newLayoutNode.options) {
+            newLayoutNode.options = {};
+        }
+        Object.assign(newLayoutNode, {
+            recursiveReference: true,
+            widget: widgetLibrary.getWidget('$ref'),
+        });
+        Object.assign(newLayoutNode.options, {
+            removable: false,
+            title: 'Add ' + newLayoutNode.$ref,
+        });
+        return newLayoutNode;
+        // Otherwise, return referenced layout
+    }
+    else {
+        let newLayoutNode = jsf.layoutRefLibrary[refNode.$ref];
+        // If value defined, build new node from schema (to set array lengths)
+        if (isDefined(nodeValue)) {
+            newLayoutNode = buildLayoutFromSchema(jsf, widgetLibrary, nodeValue, JsonPointer.toSchemaPointer(refNode.$ref, jsf.schema), refNode.$ref, newLayoutNode.arrayItem, newLayoutNode.arrayItemType, newLayoutNode.options.removable, false);
+        }
+        else {
+            // If value not defined, copy node from layoutRefLibrary
+            newLayoutNode = cloneDeep(newLayoutNode);
+            JsonPointer.forEachDeep(newLayoutNode, (subNode, pointer) => {
+                // Reset all _id's in newLayoutNode to unique values
+                if (hasOwn(subNode, '_id')) {
+                    subNode._id = uniqueId();
+                }
+                // If adding a recursive item, prefix current dataPointer
+                // to all dataPointers in new layoutNode
+                if (refNode.recursiveReference && hasOwn(subNode, 'dataPointer')) {
+                    subNode.dataPointer = refNode.dataPointer + subNode.dataPointer;
+                }
+            });
+        }
+        return newLayoutNode;
+    }
+}
+/**
+ * 'buildTitleMap' function
+ *
+ * //   titleMap -
+ * //   enumList -
+ * //  { boolean = true } fieldRequired -
+ * //  { boolean = true } flatList -
+ * // { TitleMapItem[] }
+ */
+export function buildTitleMap(titleMap, enumList, fieldRequired = true, flatList = true) {
+    let newTitleMap = [];
+    let hasEmptyValue = false;
+    if (titleMap) {
+        if (isArray(titleMap)) {
+            if (enumList) {
+                for (const i of Object.keys(titleMap)) {
+                    if (isObject(titleMap[i])) { // JSON Form style
+                        const value = titleMap[i].value;
+                        if (enumList.includes(value)) {
+                            const name = titleMap[i].name;
+                            newTitleMap.push({ name, value });
+                            if (value === undefined || value === null) {
+                                hasEmptyValue = true;
+                            }
+                        }
+                    }
+                    else if (isString(titleMap[i])) { // React Jsonschema Form style
+                        if (i < enumList.length) {
+                            const name = titleMap[i];
+                            const value = enumList[i];
+                            newTitleMap.push({ name, value });
+                            if (value === undefined || value === null) {
+                                hasEmptyValue = true;
+                            }
+                        }
+                    }
+                }
+            }
+            else { // If array titleMap and no enum list, just return the titleMap - Angular Schema Form style
+                newTitleMap = titleMap;
+                if (!fieldRequired) {
+                    hasEmptyValue = !!newTitleMap
+                        .filter(i => i.value === undefined || i.value === null)
+                        .length;
+                }
+            }
+        }
+        else if (enumList) { // Alternate JSON Form style, with enum list
+            for (const i of Object.keys(enumList)) {
+                const value = enumList[i];
+                if (hasOwn(titleMap, value)) {
+                    const name = titleMap[value];
+                    newTitleMap.push({ name, value });
+                    if (value === undefined || value === null) {
+                        hasEmptyValue = true;
+                    }
+                }
+            }
+        }
+        else { // Alternate JSON Form style, without enum list
+            for (const value of Object.keys(titleMap)) {
+                const name = titleMap[value];
+                newTitleMap.push({ name, value });
+                if (value === undefined || value === null) {
+                    hasEmptyValue = true;
+                }
+            }
+        }
+    }
+    else if (enumList) { // Build map from enum list alone
+        for (const i of Object.keys(enumList)) {
+            const name = enumList[i];
+            const value = enumList[i];
+            newTitleMap.push({ name, value });
+            if (value === undefined || value === null) {
+                hasEmptyValue = true;
+            }
+        }
+    }
+    else { // If no titleMap and no enum list, return default map of boolean values
+        newTitleMap = [{ name: 'True', value: true }, { name: 'False', value: false }];
+    }
+    // Does titleMap have groups?
+    if (newTitleMap.some(title => hasOwn(title, 'group'))) {
+        hasEmptyValue = false;
+        // If flatList = true, flatten items & update name to group: name
+        if (flatList) {
+            newTitleMap = newTitleMap.reduce((groupTitleMap, title) => {
+                if (hasOwn(title, 'group')) {
+                    if (isArray(title.items)) {
+                        groupTitleMap = [
+                            ...groupTitleMap,
+                            ...title.items.map(item => ({ ...item, ...{ name: `${title.group}: ${item.name}` } }))
+                        ];
+                        if (title.items.some(item => item.value === undefined || item.value === null)) {
+                            hasEmptyValue = true;
+                        }
+                    }
+                    if (hasOwn(title, 'name') && hasOwn(title, 'value')) {
+                        title.name = `${title.group}: ${title.name}`;
+                        delete title.group;
+                        groupTitleMap.push(title);
+                        if (title.value === undefined || title.value === null) {
+                            hasEmptyValue = true;
+                        }
+                    }
+                }
+                else {
+                    groupTitleMap.push(title);
+                    if (title.value === undefined || title.value === null) {
+                        hasEmptyValue = true;
+                    }
+                }
+                return groupTitleMap;
+            }, []);
+            // If flatList = false, combine items from matching groups
+        }
+        else {
+            newTitleMap = newTitleMap.reduce((groupTitleMap, title) => {
+                if (hasOwn(title, 'group')) {
+                    if (title.group !== (groupTitleMap[groupTitleMap.length - 1] || {}).group) {
+                        groupTitleMap.push({ group: title.group, items: title.items || [] });
+                    }
+                    if (hasOwn(title, 'name') && hasOwn(title, 'value')) {
+                        groupTitleMap[groupTitleMap.length - 1].items
+                            .push({ name: title.name, value: title.value });
+                        if (title.value === undefined || title.value === null) {
+                            hasEmptyValue = true;
+                        }
+                    }
+                }
+                else {
+                    groupTitleMap.push(title);
+                    if (title.value === undefined || title.value === null) {
+                        hasEmptyValue = true;
+                    }
+                }
+                return groupTitleMap;
+            }, []);
+        }
+    }
+    if (!fieldRequired && !hasEmptyValue) {
+        newTitleMap.unshift({ name: '<em>None</em>', value: null });
+    }
+    return newTitleMap;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout.functions.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/layout.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import cloneDeep from 'lodash/cloneDeep';\r\nimport _isArray from 'lodash/isArray';\r\nimport _isPlainObject from 'lodash/isPlainObject';\r\nimport uniqueId from 'lodash/uniqueId';\r\nimport { TitleMapItem } from '../json-schema-form.service';\r\nimport {\r\n  checkInlineType,\r\n  getFromSchema,\r\n  getInputType,\r\n  isInputRequired,\r\n  removeRecursiveReferences,\r\n  updateInputOptions\r\n} from './json-schema.functions';\r\nimport { JsonPointer } from './jsonpointer.functions';\r\nimport {\r\n  copy,\r\n  fixTitle,\r\n  forEach,\r\n  hasOwn\r\n} from './utility.functions';\r\nimport {\r\n  inArray,\r\n  isArray,\r\n  isDefined,\r\n  isEmpty,\r\n  isNumber,\r\n  isObject,\r\n  isString\r\n} from './validator.functions';\r\n\r\n\r\n\r\n\r\n/**\r\n * Layout function library:\r\n *\r\n * buildLayout:            Builds a complete layout from an input layout and schema\r\n *\r\n * buildLayoutFromSchema:  Builds a complete layout entirely from an input schema\r\n *\r\n * mapLayout:\r\n *\r\n * getLayoutNode:\r\n *\r\n * buildTitleMap:\r\n */\r\n\r\n/**\r\n * 'buildLayout' function\r\n *\r\n * //   jsf\r\n * //   widgetLibrary\r\n * //\r\n */\r\nexport function buildLayout_original(jsf, widgetLibrary) {\r\n  let hasSubmitButton = !JsonPointer.get(jsf, '/formOptions/addSubmit');\r\n  const formLayout = mapLayout(jsf.layout, (layoutItem, index, layoutPointer) => {\r\n    const newNode: any = {\r\n      _id: uniqueId(),\r\n      options: {},\r\n    };\r\n    if (isObject(layoutItem)) {\r\n      Object.assign(newNode, layoutItem);\r\n      Object.keys(newNode)\r\n        .filter(option => !inArray(option, [\r\n          '_id', '$ref', 'arrayItem', 'arrayItemType', 'dataPointer', 'dataType',\r\n          'items', 'key', 'name', 'options', 'recursiveReference', 'type', 'widget'\r\n        ]))\r\n        .forEach(option => {\r\n          newNode.options[option] = newNode[option];\r\n          delete newNode[option];\r\n        });\r\n      if (!hasOwn(newNode, 'type') && isString(newNode.widget)) {\r\n        newNode.type = newNode.widget;\r\n        delete newNode.widget;\r\n      }\r\n      if (!hasOwn(newNode.options, 'title')) {\r\n        if (hasOwn(newNode.options, 'legend')) {\r\n          newNode.options.title = newNode.options.legend;\r\n          delete newNode.options.legend;\r\n        }\r\n      }\r\n      if (!hasOwn(newNode.options, 'validationMessages')) {\r\n        if (hasOwn(newNode.options, 'errorMessages')) {\r\n          newNode.options.validationMessages = newNode.options.errorMessages;\r\n          delete newNode.options.errorMessages;\r\n\r\n          // Convert Angular Schema Form (AngularJS) 'validationMessage' to\r\n          // Angular JSON Schema Form 'validationMessages'\r\n          // TV4 codes from https://github.com/geraintluff/tv4/blob/master/source/api.js\r\n        } else if (hasOwn(newNode.options, 'validationMessage')) {\r\n          if (typeof newNode.options.validationMessage === 'string') {\r\n            newNode.options.validationMessages = newNode.options.validationMessage;\r\n          } else {\r\n            newNode.options.validationMessages = {};\r\n            Object.keys(newNode.options.validationMessage).forEach(key => {\r\n              const code = key + '';\r\n              const newKey =\r\n                code === '0' ? 'type' :\r\n                  code === '1' ? 'enum' :\r\n                    code === '100' ? 'multipleOf' :\r\n                      code === '101' ? 'minimum' :\r\n                        code === '102' ? 'exclusiveMinimum' :\r\n                          code === '103' ? 'maximum' :\r\n                            code === '104' ? 'exclusiveMaximum' :\r\n                              code === '200' ? 'minLength' :\r\n                                code === '201' ? 'maxLength' :\r\n                                  code === '202' ? 'pattern' :\r\n                                    code === '300' ? 'minProperties' :\r\n                                      code === '301' ? 'maxProperties' :\r\n                                        code === '302' ? 'required' :\r\n                                          code === '304' ? 'dependencies' :\r\n                                            code === '400' ? 'minItems' :\r\n                                              code === '401' ? 'maxItems' :\r\n                                                code === '402' ? 'uniqueItems' :\r\n                                                  code === '500' ? 'format' : code + '';\r\n              newNode.options.validationMessages[newKey] = newNode.options.validationMessage[key];\r\n            });\r\n          }\r\n          delete newNode.options.validationMessage;\r\n        }\r\n      }\r\n    } else if (JsonPointer.isJsonPointer(layoutItem)) {\r\n      newNode.dataPointer = layoutItem;\r\n    } else if (isString(layoutItem)) {\r\n      newNode.key = layoutItem;\r\n    } else {\r\n      console.error('buildLayout error: Form layout element not recognized:');\r\n      console.error(layoutItem);\r\n      return null;\r\n    }\r\n    let nodeSchema: any = null;\r\n\r\n    // If newNode does not have a dataPointer, try to find an equivalent\r\n    if (!hasOwn(newNode, 'dataPointer')) {\r\n\r\n      // If newNode has a key, change it to a dataPointer\r\n      if (hasOwn(newNode, 'key')) {\r\n        newNode.dataPointer = newNode.key === '*' ? newNode.key :\r\n          JsonPointer.compile(JsonPointer.parseObjectPath(newNode.key), '-');\r\n        delete newNode.key;\r\n\r\n        // If newNode is an array, search for dataPointer in child nodes\r\n      } else if (hasOwn(newNode, 'type') && newNode.type.slice(-5) === 'array') {\r\n        const findDataPointer = (items) => {\r\n          if (items === null || typeof items !== 'object') { return; }\r\n          if (hasOwn(items, 'dataPointer')) { return items.dataPointer; }\r\n          if (isArray(items.items)) {\r\n            for (const item of items.items) {\r\n              if (hasOwn(item, 'dataPointer') && item.dataPointer.indexOf('/-') !== -1) {\r\n                return item.dataPointer;\r\n              }\r\n              if (hasOwn(item, 'items')) {\r\n                const searchItem = findDataPointer(item);\r\n                if (searchItem) { return searchItem; }\r\n              }\r\n            }\r\n          }\r\n        };\r\n        const childDataPointer = findDataPointer(newNode);\r\n        if (childDataPointer) {\r\n          newNode.dataPointer =\r\n            childDataPointer.slice(0, childDataPointer.lastIndexOf('/-'));\r\n        }\r\n      }\r\n    }\r\n\r\n    if (hasOwn(newNode, 'dataPointer')) {\r\n      if (newNode.dataPointer === '*') {\r\n        return buildLayoutFromSchema(jsf, widgetLibrary, jsf.formValues);\r\n      }\r\n      const nodeValue =\r\n        JsonPointer.get(jsf.formValues, newNode.dataPointer.replace(/\\/-/g, '/1'));\r\n\r\n      // TODO: Create function getFormValues(jsf, dataPointer, forRefLibrary)\r\n      // check formOptions.setSchemaDefaults and formOptions.setLayoutDefaults\r\n      // then set apropriate values from initialVaues, schema, or layout\r\n\r\n      newNode.dataPointer =\r\n        JsonPointer.toGenericPointer(newNode.dataPointer, jsf.arrayMap);\r\n      const LastKey = JsonPointer.toKey(newNode.dataPointer);\r\n      if (!newNode.name && isString(LastKey) && LastKey !== '-') {\r\n        newNode.name = LastKey;\r\n      }\r\n      const shortDataPointer = removeRecursiveReferences(\r\n        newNode.dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap\r\n      );\r\n      const recursive = !shortDataPointer.length ||\r\n        shortDataPointer !== newNode.dataPointer;\r\n      let schemaPointer: string;\r\n      if (!jsf.dataMap.has(shortDataPointer)) {\r\n        jsf.dataMap.set(shortDataPointer, new Map());\r\n      }\r\n      const nodeDataMap = jsf.dataMap.get(shortDataPointer);\r\n      if (nodeDataMap.has('schemaPointer')) {\r\n        schemaPointer = nodeDataMap.get('schemaPointer');\r\n      } else {\r\n        schemaPointer = JsonPointer.toSchemaPointer(shortDataPointer, jsf.schema);\r\n        nodeDataMap.set('schemaPointer', schemaPointer);\r\n      }\r\n      nodeDataMap.set('disabled', !!newNode.options.disabled);\r\n      nodeSchema = JsonPointer.get(jsf.schema, schemaPointer);\r\n      if (nodeSchema) {\r\n        if (!hasOwn(newNode, 'type')) {\r\n          newNode.type = getInputType(nodeSchema, newNode);\r\n        } else if (!widgetLibrary.hasWidget(newNode.type)) {\r\n          const oldWidgetType = newNode.type;\r\n          newNode.type = getInputType(nodeSchema, newNode);\r\n          console.error(`error: widget type \"${oldWidgetType}\" ` +\r\n            `not found in library. Replacing with \"${newNode.type}\".`);\r\n        } else {\r\n          newNode.type = checkInlineType(newNode.type, nodeSchema, newNode);\r\n        }\r\n        if (nodeSchema.type === 'object' && isArray(nodeSchema.required)) {\r\n          nodeDataMap.set('required', nodeSchema.required);\r\n        }\r\n        newNode.dataType =\r\n          nodeSchema.type || (hasOwn(nodeSchema, '$ref') ? '$ref' : null);\r\n        updateInputOptions(newNode, nodeSchema, jsf);\r\n\r\n        // Present checkboxes as single control, rather than array\r\n        if (newNode.type === 'checkboxes' && hasOwn(nodeSchema, 'items')) {\r\n          updateInputOptions(newNode, nodeSchema.items, jsf);\r\n        } else if (newNode.dataType === 'array') {\r\n          newNode.options.maxItems = Math.min(\r\n            nodeSchema.maxItems || 1000, newNode.options.maxItems || 1000\r\n          );\r\n          newNode.options.minItems = Math.max(\r\n            nodeSchema.minItems || 0, newNode.options.minItems || 0\r\n          );\r\n          newNode.options.listItems = Math.max(\r\n            newNode.options.listItems || 0, isArray(nodeValue) ? nodeValue.length : 0\r\n          );\r\n          newNode.options.tupleItems =\r\n            isArray(nodeSchema.items) ? nodeSchema.items.length : 0;\r\n          if (newNode.options.maxItems < newNode.options.tupleItems) {\r\n            newNode.options.tupleItems = newNode.options.maxItems;\r\n            newNode.options.listItems = 0;\r\n          } else if (newNode.options.maxItems <\r\n            newNode.options.tupleItems + newNode.options.listItems\r\n          ) {\r\n            newNode.options.listItems =\r\n              newNode.options.maxItems - newNode.options.tupleItems;\r\n          } else if (newNode.options.minItems >\r\n            newNode.options.tupleItems + newNode.options.listItems\r\n          ) {\r\n            newNode.options.listItems =\r\n              newNode.options.minItems - newNode.options.tupleItems;\r\n          }\r\n          if (!nodeDataMap.has('maxItems')) {\r\n            nodeDataMap.set('maxItems', newNode.options.maxItems);\r\n            nodeDataMap.set('minItems', newNode.options.minItems);\r\n            nodeDataMap.set('tupleItems', newNode.options.tupleItems);\r\n            nodeDataMap.set('listItems', newNode.options.listItems);\r\n          }\r\n          if (!jsf.arrayMap.has(shortDataPointer)) {\r\n            jsf.arrayMap.set(shortDataPointer, newNode.options.tupleItems);\r\n          }\r\n        }\r\n        if (isInputRequired(jsf.schema, schemaPointer)) {\r\n          newNode.options.required = true;\r\n          jsf.fieldsRequired = true;\r\n        }\r\n      } else {\r\n        // TODO: create item in FormGroup model from layout key (?)\r\n        updateInputOptions(newNode, {}, jsf);\r\n      }\r\n\r\n      if (!newNode.options.title && !/^\\d+$/.test(newNode.name)) {\r\n        newNode.options.title = fixTitle(newNode.name);\r\n      }\r\n\r\n      if (hasOwn(newNode.options, 'copyValueTo')) {\r\n        if (typeof newNode.options.copyValueTo === 'string') {\r\n          newNode.options.copyValueTo = [newNode.options.copyValueTo];\r\n        }\r\n        if (isArray(newNode.options.copyValueTo)) {\r\n          newNode.options.copyValueTo = newNode.options.copyValueTo.map(item =>\r\n            JsonPointer.compile(JsonPointer.parseObjectPath(item), '-')\r\n          );\r\n        }\r\n      }\r\n\r\n      newNode.widget = widgetLibrary.getWidget(newNode.type);\r\n      nodeDataMap.set('inputType', newNode.type);\r\n      nodeDataMap.set('widget', newNode.widget);\r\n\r\n      if (newNode.dataType === 'array' &&\r\n        (hasOwn(newNode, 'items') || hasOwn(newNode, 'additionalItems'))\r\n      ) {\r\n        const itemRefPointer = removeRecursiveReferences(\r\n          newNode.dataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap\r\n        );\r\n        if (!jsf.dataMap.has(itemRefPointer)) {\r\n          jsf.dataMap.set(itemRefPointer, new Map());\r\n        }\r\n        jsf.dataMap.get(itemRefPointer).set('inputType', 'section');\r\n\r\n        // Fix insufficiently nested array item groups\r\n        if (newNode.items.length > 1) {\r\n          const arrayItemGroup = [];\r\n          for (let i = newNode.items.length - 1; i >= 0; i--) {\r\n            const subItem = newNode.items[i];\r\n            if (hasOwn(subItem, 'dataPointer') &&\r\n              subItem.dataPointer.slice(0, itemRefPointer.length) === itemRefPointer\r\n            ) {\r\n              const arrayItem = newNode.items.splice(i, 1)[0];\r\n              arrayItem.dataPointer = newNode.dataPointer + '/-' +\r\n                arrayItem.dataPointer.slice(itemRefPointer.length);\r\n              arrayItemGroup.unshift(arrayItem);\r\n            } else {\r\n              subItem.arrayItem = true;\r\n              // TODO: Check schema to get arrayItemType and removable\r\n              subItem.arrayItemType = 'list';\r\n              subItem.removable = newNode.options.removable !== false;\r\n            }\r\n          }\r\n          if (arrayItemGroup.length) {\r\n            newNode.items.push({\r\n              _id: uniqueId(),\r\n              arrayItem: true,\r\n              arrayItemType: newNode.options.tupleItems > newNode.items.length ?\r\n                'tuple' : 'list',\r\n              items: arrayItemGroup,\r\n              options: { removable: newNode.options.removable !== false, },\r\n              dataPointer: newNode.dataPointer + '/-',\r\n              type: 'section',\r\n              widget: widgetLibrary.getWidget('section'),\r\n            });\r\n          }\r\n        } else {\r\n          // TODO: Fix to hndle multiple items\r\n          newNode.items[0].arrayItem = true;\r\n          if (!newNode.items[0].dataPointer) {\r\n            newNode.items[0].dataPointer =\r\n              JsonPointer.toGenericPointer(itemRefPointer, jsf.arrayMap);\r\n          }\r\n          if (!JsonPointer.has(newNode, '/items/0/options/removable')) {\r\n            newNode.items[0].options.removable = true;\r\n          }\r\n          if (newNode.options.orderable === false) {\r\n            newNode.items[0].options.orderable = false;\r\n          }\r\n          newNode.items[0].arrayItemType =\r\n            newNode.options.tupleItems ? 'tuple' : 'list';\r\n        }\r\n\r\n        if (isArray(newNode.items)) {\r\n          const arrayListItems =\r\n            newNode.items.filter(item => item.type !== '$ref').length -\r\n            newNode.options.tupleItems;\r\n          if (arrayListItems > newNode.options.listItems) {\r\n            newNode.options.listItems = arrayListItems;\r\n            nodeDataMap.set('listItems', arrayListItems);\r\n          }\r\n        }\r\n\r\n        if (!hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {\r\n          jsf.layoutRefLibrary[itemRefPointer] =\r\n            cloneDeep(newNode.items[newNode.items.length - 1]);\r\n          if (recursive) {\r\n            jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;\r\n          }\r\n          forEach(jsf.layoutRefLibrary[itemRefPointer], (item, key) => {\r\n            if (hasOwn(item, '_id')) { item._id = null; }\r\n            if (recursive) {\r\n              if (hasOwn(item, 'dataPointer')) {\r\n                item.dataPointer = item.dataPointer.slice(itemRefPointer.length);\r\n              }\r\n            }\r\n          }, 'top-down');\r\n        }\r\n\r\n        // Add any additional default items\r\n        if (!newNode.recursiveReference || newNode.options.required) {\r\n          const arrayLength = Math.min(Math.max(\r\n            newNode.options.tupleItems + newNode.options.listItems,\r\n            isArray(nodeValue) ? nodeValue.length : 0\r\n          ), newNode.options.maxItems);\r\n          for (let i = newNode.items.length; i < arrayLength; i++) {\r\n            newNode.items.push(getLayoutNode({\r\n              $ref: itemRefPointer,\r\n              dataPointer: newNode.dataPointer,\r\n              recursiveReference: newNode.recursiveReference,\r\n            }, jsf, widgetLibrary));\r\n          }\r\n        }\r\n\r\n        // If needed, add button to add items to array\r\n        if (newNode.options.addable !== false &&\r\n          newNode.options.minItems < newNode.options.maxItems &&\r\n          (newNode.items[newNode.items.length - 1] || {}).type !== '$ref'\r\n        ) {\r\n          let buttonText = 'Add';\r\n          if (newNode.options.title) {\r\n            if (/^add\\b/i.test(newNode.options.title)) {\r\n              buttonText = newNode.options.title;\r\n            } else {\r\n              buttonText += ' ' + newNode.options.title;\r\n            }\r\n          } else if (newNode.name && !/^\\d+$/.test(newNode.name)) {\r\n            if (/^add\\b/i.test(newNode.name)) {\r\n              buttonText += ' ' + fixTitle(newNode.name);\r\n            } else {\r\n              buttonText = fixTitle(newNode.name);\r\n            }\r\n\r\n            // If newNode doesn't have a title, look for title of parent array item\r\n          } else {\r\n            const parentSchema =\r\n              getFromSchema(jsf.schema, newNode.dataPointer, 'parentSchema');\r\n            if (hasOwn(parentSchema, 'title')) {\r\n              buttonText += ' to ' + parentSchema.title;\r\n            } else {\r\n              const pointerArray = JsonPointer.parse(newNode.dataPointer);\r\n              buttonText += ' to ' + fixTitle(pointerArray[pointerArray.length - 2]);\r\n            }\r\n          }\r\n          newNode.items.push({\r\n            _id: uniqueId(),\r\n            arrayItem: true,\r\n            arrayItemType: 'list',\r\n            dataPointer: newNode.dataPointer + '/-',\r\n            options: {\r\n              listItems: newNode.options.listItems,\r\n              maxItems: newNode.options.maxItems,\r\n              minItems: newNode.options.minItems,\r\n              removable: false,\r\n              title: buttonText,\r\n              tupleItems: newNode.options.tupleItems,\r\n            },\r\n            recursiveReference: recursive,\r\n            type: '$ref',\r\n            widget: widgetLibrary.getWidget('$ref'),\r\n            $ref: itemRefPointer,\r\n          });\r\n          if (isString(JsonPointer.get(newNode, '/style/add'))) {\r\n            newNode.items[newNode.items.length - 1].options.fieldStyle =\r\n              newNode.style.add;\r\n            delete newNode.style.add;\r\n            if (isEmpty(newNode.style)) { delete newNode.style; }\r\n          }\r\n        }\r\n      } else {\r\n        newNode.arrayItem = false;\r\n      }\r\n    } else if (hasOwn(newNode, 'type') || hasOwn(newNode, 'items')) {\r\n      const parentType: string =\r\n        JsonPointer.get(jsf.layout, layoutPointer, 0, -2).type;\r\n      if (!hasOwn(newNode, 'type')) {\r\n        newNode.type =\r\n          inArray(parentType, ['tabs', 'tabarray']) ? 'tab' : 'array';\r\n      }\r\n      newNode.arrayItem = parentType === 'array';\r\n      newNode.widget = widgetLibrary.getWidget(newNode.type);\r\n      updateInputOptions(newNode, {}, jsf);\r\n    }\r\n    if (newNode.type === 'submit') { hasSubmitButton = true; }\r\n    return newNode;\r\n  });\r\n  if (jsf.hasRootReference) {\r\n    const fullLayout = cloneDeep(formLayout);\r\n    if (fullLayout[fullLayout.length - 1].type === 'submit') { fullLayout.pop(); }\r\n    jsf.layoutRefLibrary[''] = {\r\n      _id: null,\r\n      dataPointer: '',\r\n      dataType: 'object',\r\n      items: fullLayout,\r\n      name: '',\r\n      options: cloneDeep(jsf.formOptions.defaultWidgetOptions),\r\n      recursiveReference: true,\r\n      required: false,\r\n      type: 'section',\r\n      widget: widgetLibrary.getWidget('section'),\r\n    };\r\n  }\r\n  if (!hasSubmitButton) {\r\n    formLayout.push({\r\n      _id: uniqueId(),\r\n      options: { title: 'Submit' },\r\n      type: 'submit',\r\n      widget: widgetLibrary.getWidget('submit'),\r\n    });\r\n  }\r\n  return formLayout;\r\n}\r\n\r\n//TODO-review:this implements a quick 'post' fix rather than an\r\n//integrared ideal fix\r\nexport function buildLayout(jsf, widgetLibrary) {\r\n  let layout=buildLayout_original(jsf, widgetLibrary);\r\n  if (jsf.formValues) {\r\n    let fixedLayout = fixNestedArrayLayout({\r\n      builtLayout: layout,\r\n      formData: jsf.formValues\r\n    });\r\n  }\r\n  return layout;\r\n}\r\n\r\n\r\n\r\nfunction fixNestedArrayLayout(options: any) {\r\n  let { builtLayout, formData } = options;\r\n  let arrLengths = {};\r\n  let traverseObj = function (obj, path, onValue?) {\r\n    if (_isArray(obj)) {\r\n      onValue && onValue(obj, path);\r\n      obj.forEach((item, ind) => {\r\n        onValue && onValue(item, path + \"/\" + ind);\r\n        traverseObj(item, path + \"/\" + ind, onValue);\r\n      });\r\n      return;\r\n    }\r\n    if (_isPlainObject(obj)) {\r\n      onValue && onValue(obj, path);\r\n      Object.keys(obj).forEach(key => {\r\n        onValue && onValue(obj[key], path + \"/\" + key);\r\n        traverseObj(obj[key], path + \"/\" + key, onValue);\r\n      });\r\n      return\r\n    }\r\n  }\r\n  traverseObj(formData, \"\", (value, path) => {\r\n    if (_isArray(value)) {\r\n      arrLengths[path] = arrLengths[path] || value.length;\r\n    }\r\n  });\r\n\r\n  let getDataSize = (options: any) => {\r\n    let { data, dataPointer, indexArray } = options;\r\n    let dashCount = 0;\r\n    let dpInstance = dataPointer.substring(1).split(\"/\").map((part, pind) => {\r\n      if (part == \"-\" && indexArray[dashCount] != undefined) {\r\n        return indexArray[dashCount++];\r\n      }\r\n      return part;\r\n    })\r\n      .join(\"/\");\r\n    dpInstance = \"/\" + dpInstance;\r\n    let arrSize = arrLengths[dpInstance];\r\n    return arrSize;\r\n  }\r\n  //still too buggy\r\n  let createNonRefItem = (nodeWithRef: any) => {\r\n    let templateNode = {\r\n      \"type\": \"section\", //check this could also be array?\r\n      \"recursiveReference\": false,//check this \r\n      \"items\": []\r\n    }\r\n    let clone = cloneDeep(nodeWithRef);\r\n    //commented out for now so that it behaves as ususal\r\n    //_.merge(clone,templateNode);\r\n    return clone;\r\n  }\r\n\r\n  let rebuildLayout = (options: any) => {\r\n    let { builtLayout, indices, parentDataPointer, indexPos } = options;\r\n    indices = indices || [];\r\n    indexPos = indexPos == undefined ? indexPos = -1 : indexPos;\r\n    if (_isArray(builtLayout)) {\r\n      builtLayout.forEach((item, index) => {\r\n        rebuildLayout({\r\n          builtLayout: item,\r\n          indices: indices,\r\n          indexPos: indexPos,\r\n          parentDataPointer: builtLayout.dataPointer || parentDataPointer\r\n        })\r\n      })\r\n      return;\r\n    }\r\n  \r\n    let dataTypes=[\"array\"];//check only array for now\r\n     //for now added condition to ignore recursive references\r\n    if (builtLayout.items && dataTypes.indexOf(builtLayout.dataType)>=0\r\n      && builtLayout.dataPointer\r\n      && !builtLayout.recursiveReference\r\n    ) {\r\n      let numDataItems: any = getDataSize({\r\n        data: formData,\r\n        dataPointer: builtLayout.dataPointer,\r\n        indexArray: indices\r\n      });\r\n      let numActualItems = builtLayout.items.length;\r\n      //check if there's ref items, if so ignore it and therefore\r\n      //decrement the item count\r\n      builtLayout.items.forEach(item => {\r\n        if (item.type && item.type == \"$ref\") {\r\n          numActualItems--;\r\n        }\r\n      });\r\n      numActualItems = Math.max(numActualItems, 0);//avoid dealing with negatives\r\n      if (numActualItems < numDataItems) {\r\n\r\n        let numItemsNeeded = numDataItems - numActualItems;\r\n        //added to ignore recursive references\r\n        if (numActualItems == 0 && builtLayout.items[0].recursiveReference) {\r\n          numItemsNeeded = 0\r\n        }\r\n        for (let i = 0; i < numItemsNeeded; i++) {\r\n          //node must not be of type \"type\": \"$ref\"\r\n          //if it is then manufacture our own\r\n          let isRefNode = builtLayout.items[0].type && builtLayout.items[0].type == \"$ref\";\r\n          let newItem = isRefNode\r\n            ? createNonRefItem(builtLayout.items[0])\r\n            : cloneDeep(builtLayout.items[0]);//copy first\r\n          newItem._id = uniqueId(\"new_\");\r\n          builtLayout.items.unshift(newItem);\r\n        }\r\n        if (builtLayout.options.listItems) {\r\n          builtLayout.options.listItems = numDataItems;\r\n        }\r\n      }\r\n      indices[builtLayout.dataPointer] = indices[builtLayout.dataPointer] || -1;\r\n      indexPos++;\r\n      builtLayout.items.forEach((item, index) => {\r\n        indices[indexPos] = index\r\n        rebuildLayout({\r\n          builtLayout: item,\r\n          indices: indices,\r\n          parentDataPointer: builtLayout.dataPointer,\r\n          indexPos: indexPos\r\n        })\r\n      })\r\n      indexPos--;\r\n    } else {\r\n      if (builtLayout.items) {\r\n        builtLayout.items.forEach((item, index) => {\r\n          rebuildLayout({\r\n            builtLayout: item,\r\n            indices: indices,\r\n            parentDataPointer: parentDataPointer,\r\n            indexPos: indexPos\r\n          })\r\n        })\r\n\r\n      }\r\n    }\r\n\r\n\r\n  }\r\n  rebuildLayout({\r\n    builtLayout: builtLayout\r\n  });\r\n  //NB original is mutated\r\n  let fixedLayout = builtLayout;\r\n  return fixedLayout;\r\n}\r\n\r\n/**\r\n * 'buildLayoutFromSchema' function\r\n *\r\n * //   jsf -\r\n * //   widgetLibrary -\r\n * //   nodeValue -\r\n * //  { string = '' } schemaPointer -\r\n * //  { string = '' } dataPointer -\r\n * //  { boolean = false } arrayItem -\r\n * //  { string = null } arrayItemType -\r\n * //  { boolean = null } removable -\r\n * //  { boolean = false } forRefLibrary -\r\n * //  { string = '' } dataPointerPrefix -\r\n * //\r\n */\r\nexport function buildLayoutFromSchema(\r\n  jsf, widgetLibrary, nodeValue = null, schemaPointer = '',\r\n  dataPointer = '', arrayItem = false, arrayItemType: string = null,\r\n  removable: boolean = null, forRefLibrary = false, dataPointerPrefix = ''\r\n) {\r\n  const schema = JsonPointer.get(jsf.schema, schemaPointer);\r\n  if (!hasOwn(schema, 'type') && !hasOwn(schema, '$ref') &&\r\n    !hasOwn(schema, 'x-schema-form')\r\n  ) { return null; }\r\n  const newNodeType: string = getInputType(schema);\r\n  if (!isDefined(nodeValue) && (\r\n    jsf.formOptions.setSchemaDefaults === true ||\r\n    (jsf.formOptions.setSchemaDefaults === 'auto' && isEmpty(jsf.formValues))\r\n  )) {\r\n    nodeValue = JsonPointer.get(jsf.schema, schemaPointer + '/default');\r\n  }\r\n  let newNode: any = {\r\n    _id: forRefLibrary ? null : uniqueId(),\r\n    arrayItem: arrayItem,\r\n    dataPointer: JsonPointer.toGenericPointer(dataPointer, jsf.arrayMap),\r\n    dataType: schema.type || (hasOwn(schema, '$ref') ? '$ref' : null),\r\n    options: {},\r\n    required: isInputRequired(jsf.schema, schemaPointer),\r\n    type: newNodeType,\r\n    widget: widgetLibrary.getWidget(newNodeType),\r\n  };\r\n  const lastDataKey = JsonPointer.toKey(newNode.dataPointer);\r\n  if (lastDataKey !== '-') { newNode.name = lastDataKey; }\r\n  if (newNode.arrayItem) {\r\n    newNode.arrayItemType = arrayItemType;\r\n    newNode.options.removable = removable !== false;\r\n  }\r\n  const shortDataPointer = removeRecursiveReferences(\r\n    dataPointerPrefix + dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap\r\n  );\r\n  const recursive = !shortDataPointer.length ||\r\n    shortDataPointer !== dataPointerPrefix + dataPointer;\r\n  if (!jsf.dataMap.has(shortDataPointer)) {\r\n    jsf.dataMap.set(shortDataPointer, new Map());\r\n  }\r\n  const nodeDataMap = jsf.dataMap.get(shortDataPointer);\r\n  if (!nodeDataMap.has('inputType')) {\r\n    nodeDataMap.set('schemaPointer', schemaPointer);\r\n    nodeDataMap.set('inputType', newNode.type);\r\n    nodeDataMap.set('widget', newNode.widget);\r\n    nodeDataMap.set('disabled', !!newNode.options.disabled);\r\n  }\r\n  updateInputOptions(newNode, schema, jsf);\r\n  if (!newNode.options.title && newNode.name && !/^\\d+$/.test(newNode.name)) {\r\n    newNode.options.title = fixTitle(newNode.name);\r\n  }\r\n\r\n  if (newNode.dataType === 'object') {\r\n    if (isArray(schema.required) && !nodeDataMap.has('required')) {\r\n      nodeDataMap.set('required', schema.required);\r\n    }\r\n    if (isObject(schema.properties)) {\r\n      const newSection: any[] = [];\r\n      const propertyKeys = schema['ui:order'] || Object.keys(schema.properties);\r\n      if (propertyKeys.includes('*') && !hasOwn(schema.properties, '*')) {\r\n        const unnamedKeys = Object.keys(schema.properties)\r\n          .filter(key => !propertyKeys.includes(key));\r\n        for (let i = propertyKeys.length - 1; i >= 0; i--) {\r\n          if (propertyKeys[i] === '*') {\r\n            propertyKeys.splice(i, 1, ...unnamedKeys);\r\n          }\r\n        }\r\n      }\r\n      propertyKeys\r\n        .filter(key => hasOwn(schema.properties, key) ||\r\n          hasOwn(schema, 'additionalProperties')\r\n        )\r\n        .forEach(key => {\r\n          const keySchemaPointer = hasOwn(schema.properties, key) ?\r\n            '/properties/' + key : '/additionalProperties';\r\n          const innerItem = buildLayoutFromSchema(\r\n            jsf, widgetLibrary, isObject(nodeValue) ? nodeValue[key] : null,\r\n            schemaPointer + keySchemaPointer,\r\n            dataPointer + '/' + key,\r\n            false, null, null, forRefLibrary, dataPointerPrefix\r\n          );\r\n          if (innerItem) {\r\n            if (isInputRequired(schema, '/' + key)) {\r\n              innerItem.options.required = true;\r\n              jsf.fieldsRequired = true;\r\n            }\r\n            newSection.push(innerItem);\r\n          }\r\n        });\r\n      if (dataPointer === '' && !forRefLibrary) {\r\n        newNode = newSection;\r\n      } else {\r\n        newNode.items = newSection;\r\n      }\r\n    }\r\n    // TODO: Add patternProperties and additionalProperties inputs?\r\n    // ... possibly provide a way to enter both key names and values?\r\n    // if (isObject(schema.patternProperties)) { }\r\n    // if (isObject(schema.additionalProperties)) { }\r\n\r\n  } else if (newNode.dataType === 'array') {\r\n    newNode.items = [];\r\n    newNode.options.maxItems = Math.min(\r\n      schema.maxItems || 1000, newNode.options.maxItems || 1000\r\n    );\r\n    newNode.options.minItems = Math.max(\r\n      schema.minItems || 0, newNode.options.minItems || 0\r\n    );\r\n    if (!newNode.options.minItems && isInputRequired(jsf.schema, schemaPointer)) {\r\n      newNode.options.minItems = 1;\r\n    }\r\n    if (!hasOwn(newNode.options, 'listItems')) { newNode.options.listItems = 1; }\r\n    newNode.options.tupleItems = isArray(schema.items) ? schema.items.length : 0;\r\n    if (newNode.options.maxItems <= newNode.options.tupleItems) {\r\n      newNode.options.tupleItems = newNode.options.maxItems;\r\n      newNode.options.listItems = 0;\r\n    } else if (newNode.options.maxItems <\r\n      newNode.options.tupleItems + newNode.options.listItems\r\n    ) {\r\n      newNode.options.listItems = newNode.options.maxItems - newNode.options.tupleItems;\r\n    } else if (newNode.options.minItems >\r\n      newNode.options.tupleItems + newNode.options.listItems\r\n    ) {\r\n      newNode.options.listItems = newNode.options.minItems - newNode.options.tupleItems;\r\n    }\r\n    if (!nodeDataMap.has('maxItems')) {\r\n      nodeDataMap.set('maxItems', newNode.options.maxItems);\r\n      nodeDataMap.set('minItems', newNode.options.minItems);\r\n      nodeDataMap.set('tupleItems', newNode.options.tupleItems);\r\n      nodeDataMap.set('listItems', newNode.options.listItems);\r\n    }\r\n    if (!jsf.arrayMap.has(shortDataPointer)) {\r\n      jsf.arrayMap.set(shortDataPointer, newNode.options.tupleItems);\r\n    }\r\n    removable = newNode.options.removable !== false;\r\n    let additionalItemsSchemaPointer: string = null;\r\n\r\n    // If 'items' is an array = tuple items\r\n    if (isArray(schema.items)) {\r\n      newNode.items = [];\r\n      for (let i = 0; i < newNode.options.tupleItems; i++) {\r\n        let newItem: any;\r\n        const itemRefPointer = removeRecursiveReferences(\r\n          shortDataPointer + '/' + i, jsf.dataRecursiveRefMap, jsf.arrayMap\r\n        );\r\n        const itemRecursive = !itemRefPointer.length ||\r\n          itemRefPointer !== shortDataPointer + '/' + i;\r\n\r\n        // If removable, add tuple item layout to layoutRefLibrary\r\n        if (removable && i >= newNode.options.minItems) {\r\n          if (!hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {\r\n            // Set to null first to prevent recursive reference from causing endless loop\r\n            jsf.layoutRefLibrary[itemRefPointer] = null;\r\n            jsf.layoutRefLibrary[itemRefPointer] = buildLayoutFromSchema(\r\n              jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null,\r\n              schemaPointer + '/items/' + i,\r\n              itemRecursive ? '' : dataPointer + '/' + i,\r\n              true, 'tuple', true, true, itemRecursive ? dataPointer + '/' + i : ''\r\n            );\r\n            if (itemRecursive) {\r\n              jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;\r\n            }\r\n          }\r\n          newItem = getLayoutNode({\r\n            $ref: itemRefPointer,\r\n            dataPointer: dataPointer + '/' + i,\r\n            recursiveReference: itemRecursive,\r\n          }, jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null);\r\n        } else {\r\n          newItem = buildLayoutFromSchema(\r\n            jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null,\r\n            schemaPointer + '/items/' + i,\r\n            dataPointer + '/' + i,\r\n            true, 'tuple', false, forRefLibrary, dataPointerPrefix\r\n          );\r\n        }\r\n        if (newItem) { newNode.items.push(newItem); }\r\n      }\r\n\r\n      // If 'additionalItems' is an object = additional list items, after tuple items\r\n      if (isObject(schema.additionalItems)) {\r\n        additionalItemsSchemaPointer = schemaPointer + '/additionalItems';\r\n      }\r\n\r\n      // If 'items' is an object = list items only (no tuple items)\r\n    } else if (isObject(schema.items)) {\r\n      additionalItemsSchemaPointer = schemaPointer + '/items';\r\n    }\r\n\r\n    if (additionalItemsSchemaPointer) {\r\n      const itemRefPointer = removeRecursiveReferences(\r\n        shortDataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap\r\n      );\r\n      const itemRecursive = !itemRefPointer.length ||\r\n        itemRefPointer !== shortDataPointer + '/-';\r\n      const itemSchemaPointer = removeRecursiveReferences(\r\n        additionalItemsSchemaPointer, jsf.schemaRecursiveRefMap, jsf.arrayMap\r\n      );\r\n      // Add list item layout to layoutRefLibrary\r\n      if (itemRefPointer.length && !hasOwn(jsf.layoutRefLibrary, itemRefPointer)) {\r\n        // Set to null first to prevent recursive reference from causing endless loop\r\n        jsf.layoutRefLibrary[itemRefPointer] = null;\r\n        jsf.layoutRefLibrary[itemRefPointer] = buildLayoutFromSchema(\r\n          jsf, widgetLibrary, null,\r\n          itemSchemaPointer,\r\n          itemRecursive ? '' : dataPointer + '/-',\r\n          true, 'list', removable, true, itemRecursive ? dataPointer + '/-' : ''\r\n        );\r\n        if (itemRecursive) {\r\n          jsf.layoutRefLibrary[itemRefPointer].recursiveReference = true;\r\n        }\r\n      }\r\n\r\n      // Add any additional default items\r\n      if (!itemRecursive || newNode.options.required) {\r\n        const arrayLength = Math.min(Math.max(\r\n          itemRecursive ? 0 :\r\n            newNode.options.tupleItems + newNode.options.listItems,\r\n          isArray(nodeValue) ? nodeValue.length : 0\r\n        ), newNode.options.maxItems);\r\n        if (newNode.items.length < arrayLength) {\r\n          for (let i = newNode.items.length; i < arrayLength; i++) {\r\n            newNode.items.push(getLayoutNode({\r\n              $ref: itemRefPointer,\r\n              dataPointer: dataPointer + '/-',\r\n              recursiveReference: itemRecursive,\r\n            }, jsf, widgetLibrary, isArray(nodeValue) ? nodeValue[i] : null));\r\n          }\r\n        }\r\n      }\r\n\r\n      // If needed, add button to add items to array\r\n      if (newNode.options.addable !== false &&\r\n        newNode.options.minItems < newNode.options.maxItems &&\r\n        (newNode.items[newNode.items.length - 1] || {}).type !== '$ref'\r\n      ) {\r\n        let buttonText =\r\n          ((jsf.layoutRefLibrary[itemRefPointer] || {}).options || {}).title;\r\n        const prefix = buttonText ? 'Add ' : 'Add to ';\r\n        if (!buttonText) {\r\n          buttonText = schema.title || fixTitle(JsonPointer.toKey(dataPointer));\r\n        }\r\n        if (!/^add\\b/i.test(buttonText)) { buttonText = prefix + buttonText; }\r\n        newNode.items.push({\r\n          _id: uniqueId(),\r\n          arrayItem: true,\r\n          arrayItemType: 'list',\r\n          dataPointer: newNode.dataPointer + '/-',\r\n          options: {\r\n            listItems: newNode.options.listItems,\r\n            maxItems: newNode.options.maxItems,\r\n            minItems: newNode.options.minItems,\r\n            removable: false,\r\n            title: buttonText,\r\n            tupleItems: newNode.options.tupleItems,\r\n          },\r\n          recursiveReference: itemRecursive,\r\n          type: '$ref',\r\n          widget: widgetLibrary.getWidget('$ref'),\r\n          $ref: itemRefPointer,\r\n        });\r\n      }\r\n    }\r\n\r\n  } else if (newNode.dataType === '$ref') {\r\n    const schemaRef = JsonPointer.compile(schema.$ref);\r\n    const dataRef = JsonPointer.toDataPointer(schemaRef, jsf.schema);\r\n    let buttonText = '';\r\n\r\n    // Get newNode title\r\n    if (newNode.options.add) {\r\n      buttonText = newNode.options.add;\r\n    } else if (newNode.name && !/^\\d+$/.test(newNode.name)) {\r\n      buttonText =\r\n        (/^add\\b/i.test(newNode.name) ? '' : 'Add ') + fixTitle(newNode.name);\r\n\r\n      // If newNode doesn't have a title, look for title of parent array item\r\n    } else {\r\n      const parentSchema =\r\n        JsonPointer.get(jsf.schema, schemaPointer, 0, -1);\r\n      if (hasOwn(parentSchema, 'title')) {\r\n        buttonText = 'Add to ' + parentSchema.title;\r\n      } else {\r\n        const pointerArray = JsonPointer.parse(newNode.dataPointer);\r\n        buttonText = 'Add to ' + fixTitle(pointerArray[pointerArray.length - 2]);\r\n      }\r\n    }\r\n    Object.assign(newNode, {\r\n      recursiveReference: true,\r\n      widget: widgetLibrary.getWidget('$ref'),\r\n      $ref: dataRef,\r\n    });\r\n    Object.assign(newNode.options, {\r\n      removable: false,\r\n      title: buttonText,\r\n    });\r\n    if (isNumber(JsonPointer.get(jsf.schema, schemaPointer, 0, -1).maxItems)) {\r\n      newNode.options.maxItems =\r\n        JsonPointer.get(jsf.schema, schemaPointer, 0, -1).maxItems;\r\n    }\r\n\r\n    // Add layout template to layoutRefLibrary\r\n    if (dataRef.length) {\r\n      if (!hasOwn(jsf.layoutRefLibrary, dataRef)) {\r\n        // Set to null first to prevent recursive reference from causing endless loop\r\n        jsf.layoutRefLibrary[dataRef] = null;\r\n        const newLayout = buildLayoutFromSchema(\r\n          jsf, widgetLibrary, null, schemaRef, '',\r\n          newNode.arrayItem, newNode.arrayItemType, true, true, dataPointer\r\n        );\r\n        if (newLayout) {\r\n          newLayout.recursiveReference = true;\r\n          jsf.layoutRefLibrary[dataRef] = newLayout;\r\n        } else {\r\n          delete jsf.layoutRefLibrary[dataRef];\r\n        }\r\n      } else if (!jsf.layoutRefLibrary[dataRef].recursiveReference) {\r\n        jsf.layoutRefLibrary[dataRef].recursiveReference = true;\r\n      }\r\n    }\r\n  }\r\n  return newNode;\r\n}\r\n\r\n/**\r\n * 'mapLayout' function\r\n *\r\n * Creates a new layout by running each element in an existing layout through\r\n * an iteratee. Recursively maps within array elements 'items' and 'tabs'.\r\n * The iteratee is invoked with four arguments: (value, index, layout, path)\r\n *\r\n * The returned layout may be longer (or shorter) then the source layout.\r\n *\r\n * If an item from the source layout returns multiple items (as '*' usually will),\r\n * this function will keep all returned items in-line with the surrounding items.\r\n *\r\n * If an item from the source layout causes an error and returns null, it is\r\n * skipped without error, and the function will still return all non-null items.\r\n *\r\n * //   layout - the layout to map\r\n * //  { (v: any, i?: number, l?: any, p?: string) => any }\r\n *   function - the funciton to invoke on each element\r\n * //  { string|string[] = '' } layoutPointer - the layoutPointer to layout, inside rootLayout\r\n * //  { any[] = layout } rootLayout - the root layout, which conatins layout\r\n * //\r\n */\r\nexport function mapLayout(layout, fn, layoutPointer = '', rootLayout = layout) {\r\n  let indexPad = 0;\r\n  let newLayout: any[] = [];\r\n  forEach(layout, (item, index) => {\r\n    const realIndex = +index + indexPad;\r\n    const newLayoutPointer = layoutPointer + '/' + realIndex;\r\n    let newNode: any = copy(item);\r\n    let itemsArray: any[] = [];\r\n    if (isObject(item)) {\r\n      if (hasOwn(item, 'tabs')) {\r\n        item.items = item.tabs;\r\n        delete item.tabs;\r\n      }\r\n      if (hasOwn(item, 'items')) {\r\n        itemsArray = isArray(item.items) ? item.items : [item.items];\r\n      }\r\n    }\r\n    if (itemsArray.length) {\r\n      newNode.items = mapLayout(itemsArray, fn, newLayoutPointer + '/items', rootLayout);\r\n    }\r\n    newNode = fn(newNode, realIndex, newLayoutPointer, rootLayout);\r\n    if (!isDefined(newNode)) {\r\n      indexPad--;\r\n    } else {\r\n      if (isArray(newNode)) { indexPad += newNode.length - 1; }\r\n      newLayout = newLayout.concat(newNode);\r\n    }\r\n  });\r\n  return newLayout;\r\n}\r\n\r\n/**\r\n * 'getLayoutNode' function\r\n * Copy a new layoutNode from layoutRefLibrary\r\n *\r\n * //   refNode -\r\n * //   layoutRefLibrary -\r\n * //  { any = null } widgetLibrary -\r\n * //  { any = null } nodeValue -\r\n * //  copied layoutNode\r\n */\r\nexport function getLayoutNode(\r\n  refNode, jsf, widgetLibrary: any = null, nodeValue: any = null\r\n) {\r\n\r\n  // If recursive reference and building initial layout, return Add button\r\n  if (refNode.recursiveReference && widgetLibrary) {\r\n    const newLayoutNode = cloneDeep(refNode);\r\n    if (!newLayoutNode.options) { newLayoutNode.options = {}; }\r\n    Object.assign(newLayoutNode, {\r\n      recursiveReference: true,\r\n      widget: widgetLibrary.getWidget('$ref'),\r\n    });\r\n    Object.assign(newLayoutNode.options, {\r\n      removable: false,\r\n      title: 'Add ' + newLayoutNode.$ref,\r\n    });\r\n    return newLayoutNode;\r\n\r\n    // Otherwise, return referenced layout\r\n  } else {\r\n    let newLayoutNode = jsf.layoutRefLibrary[refNode.$ref];\r\n    // If value defined, build new node from schema (to set array lengths)\r\n    if (isDefined(nodeValue)) {\r\n      newLayoutNode = buildLayoutFromSchema(\r\n        jsf, widgetLibrary, nodeValue,\r\n        JsonPointer.toSchemaPointer(refNode.$ref, jsf.schema),\r\n        refNode.$ref, newLayoutNode.arrayItem,\r\n        newLayoutNode.arrayItemType, newLayoutNode.options.removable, false\r\n      );\r\n    } else {\r\n      // If value not defined, copy node from layoutRefLibrary\r\n      newLayoutNode = cloneDeep(newLayoutNode);\r\n      JsonPointer.forEachDeep(newLayoutNode, (subNode, pointer) => {\r\n\r\n        // Reset all _id's in newLayoutNode to unique values\r\n        if (hasOwn(subNode, '_id')) { subNode._id = uniqueId(); }\r\n\r\n        // If adding a recursive item, prefix current dataPointer\r\n        // to all dataPointers in new layoutNode\r\n        if (refNode.recursiveReference && hasOwn(subNode, 'dataPointer')) {\r\n          subNode.dataPointer = refNode.dataPointer + subNode.dataPointer;\r\n        }\r\n      });\r\n    }\r\n    return newLayoutNode;\r\n  }\r\n}\r\n\r\n/**\r\n * 'buildTitleMap' function\r\n *\r\n * //   titleMap -\r\n * //   enumList -\r\n * //  { boolean = true } fieldRequired -\r\n * //  { boolean = true } flatList -\r\n * // { TitleMapItem[] }\r\n */\r\nexport function buildTitleMap(\r\n  titleMap, enumList, fieldRequired = true, flatList = true\r\n) {\r\n  let newTitleMap: TitleMapItem[] = [];\r\n  let hasEmptyValue = false;\r\n  if (titleMap) {\r\n    if (isArray(titleMap)) {\r\n      if (enumList) {\r\n        for (const i of Object.keys(titleMap)) {\r\n          if (isObject(titleMap[i])) { // JSON Form style\r\n            const value = titleMap[i].value;\r\n            if (enumList.includes(value)) {\r\n              const name = titleMap[i].name;\r\n              newTitleMap.push({ name, value });\r\n              if (value === undefined || value === null) { hasEmptyValue = true; }\r\n            }\r\n          } else if (isString(titleMap[i])) { // React Jsonschema Form style\r\n            if (i < enumList.length) {\r\n              const name = titleMap[i];\r\n              const value = enumList[i];\r\n              newTitleMap.push({ name, value });\r\n              if (value === undefined || value === null) { hasEmptyValue = true; }\r\n            }\r\n          }\r\n        }\r\n      } else { // If array titleMap and no enum list, just return the titleMap - Angular Schema Form style\r\n        newTitleMap = titleMap;\r\n        if (!fieldRequired) {\r\n          hasEmptyValue = !!newTitleMap\r\n            .filter(i => i.value === undefined || i.value === null)\r\n            .length;\r\n        }\r\n      }\r\n    } else if (enumList) { // Alternate JSON Form style, with enum list\r\n      for (const i of Object.keys(enumList)) {\r\n        const value = enumList[i];\r\n        if (hasOwn(titleMap, value)) {\r\n          const name = titleMap[value];\r\n          newTitleMap.push({ name, value });\r\n          if (value === undefined || value === null) { hasEmptyValue = true; }\r\n        }\r\n      }\r\n    } else { // Alternate JSON Form style, without enum list\r\n      for (const value of Object.keys(titleMap)) {\r\n        const name = titleMap[value];\r\n        newTitleMap.push({ name, value });\r\n        if (value === undefined || value === null) { hasEmptyValue = true; }\r\n      }\r\n    }\r\n  } else if (enumList) { // Build map from enum list alone\r\n    for (const i of Object.keys(enumList)) {\r\n      const name = enumList[i];\r\n      const value = enumList[i];\r\n      newTitleMap.push({ name, value });\r\n      if (value === undefined || value === null) { hasEmptyValue = true; }\r\n    }\r\n  } else { // If no titleMap and no enum list, return default map of boolean values\r\n    newTitleMap = [{ name: 'True', value: true }, { name: 'False', value: false }];\r\n  }\r\n\r\n  // Does titleMap have groups?\r\n  if (newTitleMap.some(title => hasOwn(title, 'group'))) {\r\n    hasEmptyValue = false;\r\n\r\n    // If flatList = true, flatten items & update name to group: name\r\n    if (flatList) {\r\n      newTitleMap = newTitleMap.reduce((groupTitleMap, title) => {\r\n        if (hasOwn(title, 'group')) {\r\n          if (isArray(title.items)) {\r\n            groupTitleMap = [\r\n              ...groupTitleMap,\r\n              ...title.items.map(item =>\r\n                ({ ...item, ...{ name: `${title.group}: ${item.name}` } })\r\n              )\r\n            ];\r\n            if (title.items.some(item => item.value === undefined || item.value === null)) {\r\n              hasEmptyValue = true;\r\n            }\r\n          }\r\n          if (hasOwn(title, 'name') && hasOwn(title, 'value')) {\r\n            title.name = `${title.group}: ${title.name}`;\r\n            delete title.group;\r\n            groupTitleMap.push(title);\r\n            if (title.value === undefined || title.value === null) {\r\n              hasEmptyValue = true;\r\n            }\r\n          }\r\n        } else {\r\n          groupTitleMap.push(title);\r\n          if (title.value === undefined || title.value === null) {\r\n            hasEmptyValue = true;\r\n          }\r\n        }\r\n        return groupTitleMap;\r\n      }, []);\r\n\r\n      // If flatList = false, combine items from matching groups\r\n    } else {\r\n      newTitleMap = newTitleMap.reduce((groupTitleMap, title) => {\r\n        if (hasOwn(title, 'group')) {\r\n          if (title.group !== (groupTitleMap[groupTitleMap.length - 1] || {}).group) {\r\n            groupTitleMap.push({ group: title.group, items: title.items || [] });\r\n          }\r\n          if (hasOwn(title, 'name') && hasOwn(title, 'value')) {\r\n            groupTitleMap[groupTitleMap.length - 1].items\r\n              .push({ name: title.name, value: title.value });\r\n            if (title.value === undefined || title.value === null) {\r\n              hasEmptyValue = true;\r\n            }\r\n          }\r\n        } else {\r\n          groupTitleMap.push(title);\r\n          if (title.value === undefined || title.value === null) {\r\n            hasEmptyValue = true;\r\n          }\r\n        }\r\n        return groupTitleMap;\r\n      }, []);\r\n    }\r\n  }\r\n  if (!fieldRequired && !hasEmptyValue) {\r\n    newTitleMap.unshift({ name: '<em>None</em>', value: null });\r\n  }\r\n  return newTitleMap;\r\n}\r\n"]}