@ng-formworks/core 17.2.7 → 17.4.0

package/esm2022/lib/json-schema-form.service.mjs

@@ -0,0 +1,679 @@
+import { Injectable } from '@angular/core';
+//import Ajv, { ErrorObject, Options } from 'ajv';
+import Ajv2019 from 'ajv/dist/2019';
+import jsonDraft6 from 'ajv/lib/refs/json-schema-draft-06.json';
+import jsonDraft7 from 'ajv/lib/refs/json-schema-draft-07.json';
+import cloneDeep from 'lodash/cloneDeep';
+import { Subject } from 'rxjs';
+import { deValidationMessages, enValidationMessages, esValidationMessages, frValidationMessages, itValidationMessages, ptValidationMessages, zhValidationMessages } from './locale';
+import { JsonPointer, buildFormGroup, buildFormGroupTemplate, buildLayout, buildSchemaFromData, buildSchemaFromLayout, fixTitle, forEach, formatFormData, getControl, getLayoutNode, hasOwn, hasValue, isArray, isDefined, isEmpty, isObject, removeRecursiveReferences, toTitleCase } from './shared';
+import _isEqual from 'lodash/isEqual';
+import * as i0 from "@angular/core";
+export class JsonSchemaFormService {
+    constructor() {
+        this.JsonFormCompatibility = false;
+        this.ReactJsonSchemaFormCompatibility = false;
+        this.AngularSchemaFormCompatibility = false;
+        this.tpldata = {};
+        this.ajvOptions = {
+            allErrors: true,
+            validateFormats: false,
+            strict: false
+        };
+        this.ajv = new Ajv2019(this.ajvOptions); // AJV: Another JSON Schema Validator
+        this.validateFormData = null; // Compiled AJV function to validate active form's schema
+        this.formValues = {}; // Internal form data (may not have correct types)
+        this.data = {}; // Output form data (formValues, formatted with correct data types)
+        this.schema = {}; // Internal JSON Schema
+        this.layout = []; // Internal form layout
+        this.formGroupTemplate = {}; // Template used to create formGroup
+        this.formGroup = null; // Angular formGroup, which powers the reactive form
+        this.framework = null; // Active framework component
+        this.validData = null; // Valid form data (or null) (=== isValid ? data : null)
+        this.isValid = null; // Is current form data valid?
+        this.ajvErrors = null; // Ajv errors for current data
+        this.validationErrors = null; // Any validation errors for current data
+        this.dataErrors = new Map(); //
+        this.formValueSubscription = null; // Subscription to formGroup.valueChanges observable (for un- and re-subscribing)
+        this.dataChanges = new Subject(); // Form data observable
+        this.isValidChanges = new Subject(); // isValid observable
+        this.validationErrorChanges = new Subject(); // validationErrors observable
+        this.arrayMap = new Map(); // Maps arrays in data object and number of tuple values
+        this.dataMap = new Map(); // Maps paths in form data to schema and formGroup paths
+        this.dataRecursiveRefMap = new Map(); // Maps recursive reference points in form data
+        this.schemaRecursiveRefMap = new Map(); // Maps recursive reference points in schema
+        this.schemaRefLibrary = {}; // Library of schemas for resolving schema $refs
+        this.layoutRefLibrary = { '': null }; // Library of layout nodes for adding to form
+        this.templateRefLibrary = {}; // Library of formGroup templates for adding to form
+        this.hasRootReference = false; // Does the form include a recursive reference to itself?
+        this.language = 'en-US'; // Does the form include a recursive reference to itself?
+        // Default global form options
+        this.defaultFormOptions = {
+            autocomplete: true,
+            addSubmit: 'auto',
+            // for addSubmit: true = always, false = never,
+            // 'auto' = only if layout is undefined (form is built from schema alone)
+            debug: false,
+            disableInvalidSubmit: true,
+            formDisabled: false,
+            formReadonly: false,
+            fieldsRequired: false,
+            framework: 'no-framework',
+            loadExternalAssets: false,
+            pristine: { errors: true, success: true },
+            supressPropertyTitles: false,
+            setSchemaDefaults: 'auto',
+            // true = always set (unless overridden by layout default or formValues)
+            // false = never set
+            // 'auto' = set in addable components, and everywhere if formValues not set
+            setLayoutDefaults: 'auto',
+            // true = always set (unless overridden by formValues)
+            // false = never set
+            // 'auto' = set in addable components, and everywhere if formValues not set
+            validateOnRender: 'auto',
+            // true = validate all fields immediately
+            // false = only validate fields after they are touched by user
+            // 'auto' = validate fields with values immediately, empty fields after they are touched
+            widgets: {},
+            defaultWidgetOptions: {
+                // Default options for form control widgets
+                listItems: 1,
+                addable: true,
+                orderable: true,
+                removable: true,
+                enableErrorState: true,
+                // disableErrorState: false, // Don't apply 'has-error' class when field fails validation?
+                enableSuccessState: true,
+                // disableSuccessState: false, // Don't apply 'has-success' class when field validates?
+                feedback: false,
+                feedbackOnRender: false,
+                notitle: false,
+                disabled: false,
+                readonly: false,
+                returnEmptyFields: true,
+                validationMessages: {} // set by setLanguage()
+            }
+        };
+        this.setLanguage(this.language);
+        this.ajv.addMetaSchema(jsonDraft6);
+        this.ajv.addMetaSchema(jsonDraft7);
+    }
+    ngOnDestroy() {
+        this.fcValueChangesSubs?.unsubscribe();
+        this.fcStatusChangesSubs?.unsubscribe();
+        this.formValueSubscription?.unsubscribe();
+        this.fcValueChangesSubs = null;
+        this.fcStatusChangesSubs = null;
+        this.formValueSubscription = null;
+    }
+    setLanguage(language = 'en-US') {
+        this.language = language;
+        const languageValidationMessages = {
+            de: deValidationMessages,
+            en: enValidationMessages,
+            es: esValidationMessages,
+            fr: frValidationMessages,
+            it: itValidationMessages,
+            pt: ptValidationMessages,
+            zh: zhValidationMessages,
+        };
+        const languageCode = language.slice(0, 2);
+        const validationMessages = languageValidationMessages[languageCode];
+        this.defaultFormOptions.defaultWidgetOptions.validationMessages = cloneDeep(validationMessages);
+    }
+    getData() {
+        return this.data;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    getLayout() {
+        return this.layout;
+    }
+    resetAllValues() {
+        this.JsonFormCompatibility = false;
+        this.ReactJsonSchemaFormCompatibility = false;
+        this.AngularSchemaFormCompatibility = false;
+        this.tpldata = {};
+        this.validateFormData = null;
+        this.formValues = {};
+        this.schema = {};
+        this.layout = [];
+        this.formGroupTemplate = {};
+        this.formGroup = null;
+        this.framework = null;
+        this.data = {};
+        this.validData = null;
+        this.isValid = null;
+        this.validationErrors = null;
+        this.arrayMap = new Map();
+        this.dataMap = new Map();
+        this.dataRecursiveRefMap = new Map();
+        this.schemaRecursiveRefMap = new Map();
+        this.layoutRefLibrary = {};
+        this.schemaRefLibrary = {};
+        this.templateRefLibrary = {};
+        this.formOptions = cloneDeep(this.defaultFormOptions);
+    }
+    /**
+     * 'buildRemoteError' function
+     *
+     * Example errors:
+     * {
+     *   last_name: [ {
+     *     message: 'Last name must by start with capital letter.',
+     *     code: 'capital_letter'
+     *   } ],
+     *   email: [ {
+     *     message: 'Email must be from example.com domain.',
+     *     code: 'special_domain'
+     *   }, {
+     *     message: 'Email must contain an @ symbol.',
+     *     code: 'at_symbol'
+     *   } ]
+     * }
+     * //{ErrorMessages} errors
+     */
+    buildRemoteError(errors) {
+        forEach(errors, (value, key) => {
+            if (key in this.formGroup.controls) {
+                for (const error of value) {
+                    const err = {};
+                    err[error['code']] = error['message'];
+                    this.formGroup.get(key).setErrors(err, { emitEvent: true });
+                }
+            }
+        });
+    }
+    validateData(newValue, updateSubscriptions = true) {
+        // Format raw form data to correct data types
+        this.data = formatFormData(newValue, this.dataMap, this.dataRecursiveRefMap, this.arrayMap, this.formOptions.returnEmptyFields);
+        this.isValid = this.validateFormData(this.data);
+        this.validData = this.isValid ? this.data : null;
+        const compileErrors = (errors) => {
+            const compiledErrors = {};
+            (errors || []).forEach(error => {
+                //TODO review-seems to be a change in newer versions
+                //of ajv giving '' as instancePath for root objects
+                let errorPath = error.instancePath || "ROOT";
+                if (!compiledErrors[errorPath]) {
+                    compiledErrors[errorPath] = [];
+                }
+                compiledErrors[errorPath].push(error.message);
+            });
+            return compiledErrors;
+        };
+        this.ajvErrors = this.validateFormData.errors;
+        this.validationErrors = compileErrors(this.validateFormData.errors);
+        if (updateSubscriptions) {
+            this.dataChanges.next(this.data);
+            this.isValidChanges.next(this.isValid);
+            this.validationErrorChanges.next(this.ajvErrors);
+        }
+    }
+    buildFormGroupTemplate(formValues = null, setValues = true) {
+        this.formGroupTemplate = buildFormGroupTemplate(this, formValues, setValues);
+    }
+    buildFormGroup() {
+        this.formGroup = buildFormGroup(this.formGroupTemplate);
+        if (this.formGroup) {
+            this.compileAjvSchema();
+            this.validateData(this.formGroup.value);
+            // Set up observables to emit data and validation info when form data changes
+            if (this.formValueSubscription) {
+                this.formValueSubscription.unsubscribe();
+            }
+            this.formValueSubscription = this.formGroup.valueChanges.subscribe(formValue => this.validateData(formValue));
+        }
+    }
+    buildLayout(widgetLibrary) {
+        this.layout = buildLayout(this, widgetLibrary);
+    }
+    setOptions(newOptions) {
+        if (isObject(newOptions)) {
+            const addOptions = cloneDeep(newOptions);
+            // Backward compatibility for 'defaultOptions' (renamed 'defaultWidgetOptions')
+            if (isObject(addOptions.defaultOptions)) {
+                Object.assign(this.formOptions.defaultWidgetOptions, addOptions.defaultOptions);
+                delete addOptions.defaultOptions;
+            }
+            if (isObject(addOptions.defaultWidgetOptions)) {
+                Object.assign(this.formOptions.defaultWidgetOptions, addOptions.defaultWidgetOptions);
+                delete addOptions.defaultWidgetOptions;
+            }
+            Object.assign(this.formOptions, addOptions);
+            // convert disableErrorState / disableSuccessState to enable...
+            const globalDefaults = this.formOptions.defaultWidgetOptions;
+            ['ErrorState', 'SuccessState']
+                .filter(suffix => hasOwn(globalDefaults, 'disable' + suffix))
+                .forEach(suffix => {
+                globalDefaults['enable' + suffix] = !globalDefaults['disable' + suffix];
+                delete globalDefaults['disable' + suffix];
+            });
+        }
+    }
+    compileAjvSchema() {
+        if (!this.validateFormData) {
+            // if 'ui:order' exists in properties, move it to root before compiling with ajv
+            if (Array.isArray(this.schema.properties['ui:order'])) {
+                this.schema['ui:order'] = this.schema.properties['ui:order'];
+                delete this.schema.properties['ui:order'];
+            }
+            this.ajv.removeSchema(this.schema);
+            this.validateFormData = this.ajv.compile(this.schema);
+        }
+    }
+    buildSchemaFromData(data, requireAllFields = false) {
+        if (data) {
+            return buildSchemaFromData(data, requireAllFields);
+        }
+        this.schema = buildSchemaFromData(this.formValues, requireAllFields);
+    }
+    buildSchemaFromLayout(layout) {
+        if (layout) {
+            return buildSchemaFromLayout(layout);
+        }
+        this.schema = buildSchemaFromLayout(this.layout);
+    }
+    setTpldata(newTpldata = {}) {
+        this.tpldata = newTpldata;
+    }
+    parseText(text = '', value = {}, values = {}, key = null) {
+        if (!text || !/{{.+?}}/.test(text)) {
+            return text;
+        }
+        return text.replace(/{{(.+?)}}/g, (...a) => this.parseExpression(a[1], value, values, key, this.tpldata));
+    }
+    parseExpression(expression = '', value = {}, values = {}, key = null, tpldata = null) {
+        if (typeof expression !== 'string') {
+            return '';
+        }
+        const index = typeof key === 'number' ? key + 1 + '' : key || '';
+        expression = expression.trim();
+        if ((expression[0] === "'" || expression[0] === '"') &&
+            expression[0] === expression[expression.length - 1] &&
+            expression.slice(1, expression.length - 1).indexOf(expression[0]) === -1) {
+            return expression.slice(1, expression.length - 1);
+        }
+        if (expression === 'idx' || expression === '$index') {
+            return index;
+        }
+        if (expression === 'value' && !hasOwn(values, 'value')) {
+            return value;
+        }
+        if (['"', "'", ' ', '||', '&&', '+'].every(delim => expression.indexOf(delim) === -1)) {
+            const pointer = JsonPointer.parseObjectPath(expression);
+            return pointer[0] === 'value' && JsonPointer.has(value, pointer.slice(1))
+                ? JsonPointer.get(value, pointer.slice(1))
+                : pointer[0] === 'values' && JsonPointer.has(values, pointer.slice(1))
+                    ? JsonPointer.get(values, pointer.slice(1))
+                    : pointer[0] === 'tpldata' && JsonPointer.has(tpldata, pointer.slice(1))
+                        ? JsonPointer.get(tpldata, pointer.slice(1))
+                        : JsonPointer.has(values, pointer)
+                            ? JsonPointer.get(values, pointer)
+                            : '';
+        }
+        if (expression.indexOf('[idx]') > -1) {
+            expression = expression.replace(/\[idx\]/g, index);
+        }
+        if (expression.indexOf('[$index]') > -1) {
+            expression = expression.replace(/\[$index\]/g, index);
+        }
+        // TODO: Improve expression evaluation by parsing quoted strings first
+        // let expressionArray = expression.match(/([^"']+|"[^"]+"|'[^']+')/g);
+        if (expression.indexOf('||') > -1) {
+            return expression
+                .split('||')
+                .reduce((all, term) => all || this.parseExpression(term, value, values, key, tpldata), '');
+        }
+        if (expression.indexOf('&&') > -1) {
+            return expression
+                .split('&&')
+                .reduce((all, term) => all && this.parseExpression(term, value, values, key, tpldata), ' ')
+                .trim();
+        }
+        if (expression.indexOf('+') > -1) {
+            return expression
+                .split('+')
+                .map(term => this.parseExpression(term, value, values, key, tpldata))
+                .join('');
+        }
+        return '';
+    }
+    setArrayItemTitle(parentCtx = {}, childNode = null, index = null) {
+        const parentNode = parentCtx.layoutNode;
+        const parentValues = this.getFormControlValue(parentCtx);
+        const isArrayItem = (parentNode.type || '').slice(-5) === 'array' && isArray(parentValues);
+        const text = JsonPointer.getFirst(isArrayItem && childNode.type !== '$ref'
+            ? [
+                [childNode, '/options/legend'],
+                [childNode, '/options/title'],
+                [parentNode, '/options/title'],
+                [parentNode, '/options/legend']
+            ]
+            : [
+                [childNode, '/options/title'],
+                [childNode, '/options/legend'],
+                [parentNode, '/options/title'],
+                [parentNode, '/options/legend']
+            ]);
+        if (!text) {
+            return text;
+        }
+        const childValue = isArray(parentValues) && index < parentValues.length
+            ? parentValues[index]
+            : parentValues;
+        return this.parseText(text, childValue, parentValues, index);
+    }
+    setItemTitle(ctx) {
+        return !ctx.options.title && /^(\d+|-)$/.test(ctx.layoutNode.name)
+            ? null
+            : this.parseText(ctx.options.title || toTitleCase(ctx.layoutNode.name), this.getFormControlValue(this), (this.getFormControlGroup(this) || {}).value, ctx.dataIndex[ctx.dataIndex.length - 1]);
+    }
+    evaluateCondition(layoutNode, dataIndex) {
+        const arrayIndex = dataIndex && dataIndex[dataIndex.length - 1];
+        let result = true;
+        if (hasValue((layoutNode.options || {}).condition)) {
+            if (typeof layoutNode.options.condition === 'string') {
+                let pointer = layoutNode.options.condition;
+                if (hasValue(arrayIndex)) {
+                    pointer = pointer.replace('[arrayIndex]', `[${arrayIndex}]`);
+                }
+                pointer = JsonPointer.parseObjectPath(pointer);
+                result = !!JsonPointer.get(this.data, pointer);
+                if (!result && pointer[0] === 'model') {
+                    result = !!JsonPointer.get({ model: this.data }, pointer);
+                }
+            }
+            else if (typeof layoutNode.options.condition === 'function') {
+                result = layoutNode.options.condition(this.data);
+            }
+            else if (typeof layoutNode.options.condition.functionBody === 'string') {
+                try {
+                    const dynFn = new Function('model', 'arrayIndices', layoutNode.options.condition.functionBody);
+                    result = dynFn(this.data, dataIndex);
+                }
+                catch (e) {
+                    result = true;
+                    console.error('condition functionBody errored out on evaluation: ' +
+                        layoutNode.options.condition.functionBody);
+                }
+            }
+        }
+        return result;
+    }
+    initializeControl(ctx, bind = true) {
+        if (!isObject(ctx)) {
+            return false;
+        }
+        if (isEmpty(ctx.options)) {
+            ctx.options = !isEmpty((ctx.layoutNode || {}).options)
+                ? ctx.layoutNode.options
+                : cloneDeep(this.formOptions);
+        }
+        ctx.formControl = this.getFormControl(ctx);
+        ctx.boundControl = bind && !!ctx.formControl;
+        if (ctx.formControl) {
+            ctx.controlName = this.getFormControlName(ctx);
+            ctx.controlValue = ctx.formControl.value;
+            ctx.controlDisabled = ctx.formControl.disabled;
+            ctx.options.errorMessage =
+                ctx.formControl.status === 'VALID'
+                    ? null
+                    : this.formatErrors(ctx.formControl.errors, ctx.options.validationMessages);
+            ctx.options.showErrors =
+                this.formOptions.validateOnRender === true ||
+                    (this.formOptions.validateOnRender === 'auto' &&
+                        hasValue(ctx.controlValue));
+            this.fcStatusChangesSubs = ctx.formControl.statusChanges.subscribe(status => (ctx.options.errorMessage =
+                status === 'VALID'
+                    ? null
+                    : this.formatErrors(ctx.formControl.errors, ctx.options.validationMessages)));
+            this.fcValueChangesSubs = ctx.formControl.valueChanges.subscribe(value => {
+                //commented out to revert back to previous commits
+                //as seems to be causing some issues
+                /*
+               if (!!value) {
+                 ctx.controlValue = value;
+               }
+               */
+                //TODO-test,this is the original code
+                if (!_isEqual(ctx.controlValue, value)) {
+                    ctx.controlValue = value;
+                }
+            });
+        }
+        else {
+            ctx.controlName = ctx.layoutNode.name;
+            ctx.controlValue = ctx.layoutNode.value || null;
+            const dataPointer = this.getDataPointer(ctx);
+            if (bind && dataPointer) {
+                console.error(`warning: control "${dataPointer}" is not bound to the Angular FormGroup.`);
+            }
+        }
+        return ctx.boundControl;
+    }
+    formatErrors(errors, validationMessages = {}) {
+        if (isEmpty(errors)) {
+            return null;
+        }
+        if (!isObject(validationMessages)) {
+            validationMessages = {};
+        }
+        const addSpaces = string => string[0].toUpperCase() +
+            (string.slice(1) || '')
+                .replace(/([a-z])([A-Z])/g, '$1 $2')
+                .replace(/_/g, ' ');
+        const formatError = error => typeof error === 'object'
+            ? Object.keys(error)
+                .map(key => error[key] === true
+                ? addSpaces(key)
+                : error[key] === false
+                    ? 'Not ' + addSpaces(key)
+                    : addSpaces(key) + ': ' + formatError(error[key]))
+                .join(', ')
+            : addSpaces(error.toString());
+        const messages = [];
+        return (Object.keys(errors)
+            // Hide 'required' error, unless it is the only one
+            .filter(errorKey => errorKey !== 'required' || Object.keys(errors).length === 1)
+            .map(errorKey => 
+        // If validationMessages is a string, return it
+        typeof validationMessages === 'string'
+            ? validationMessages
+            : // If custom error message is a function, return function result
+                typeof validationMessages[errorKey] === 'function'
+                    ? validationMessages[errorKey](errors[errorKey])
+                    : // If custom error message is a string, replace placeholders and return
+                        typeof validationMessages[errorKey] === 'string'
+                            ? // Does error message have any {{property}} placeholders?
+                                !/{{.+?}}/.test(validationMessages[errorKey])
+                                    ? validationMessages[errorKey]
+                                    : // Replace {{property}} placeholders with values
+                                        Object.keys(errors[errorKey]).reduce((errorMessage, errorProperty) => errorMessage.replace(new RegExp('{{' + errorProperty + '}}', 'g'), errors[errorKey][errorProperty]), validationMessages[errorKey])
+                            : // If no custom error message, return formatted error data instead
+                                addSpaces(errorKey) + ' Error: ' + formatError(errors[errorKey]))
+            .join('<br>'));
+    }
+    updateValue(ctx, value) {
+        // Set value of current control
+        ctx.controlValue = value;
+        if (ctx.boundControl) {
+            ctx.formControl.setValue(value);
+            ctx.formControl.markAsDirty();
+        }
+        ctx.layoutNode.value = value;
+        // Set values of any related controls in copyValueTo array
+        if (isArray(ctx.options.copyValueTo)) {
+            for (const item of ctx.options.copyValueTo) {
+                const targetControl = getControl(this.formGroup, item);
+                if (isObject(targetControl) &&
+                    typeof targetControl.setValue === 'function') {
+                    targetControl.setValue(value);
+                    targetControl.markAsDirty();
+                }
+            }
+        }
+    }
+    updateArrayCheckboxList(ctx, checkboxList) {
+        const formArray = this.getFormControl(ctx);
+        // Remove all existing items
+        while (formArray.value.length) {
+            formArray.removeAt(0);
+        }
+        // Re-add an item for each checked box
+        const refPointer = removeRecursiveReferences(ctx.layoutNode.dataPointer + '/-', this.dataRecursiveRefMap, this.arrayMap);
+        for (const checkboxItem of checkboxList) {
+            if (checkboxItem.checked) {
+                const newFormControl = buildFormGroup(this.templateRefLibrary[refPointer]);
+                newFormControl.setValue(checkboxItem.value);
+                formArray.push(newFormControl);
+            }
+        }
+        formArray.markAsDirty();
+    }
+    getFormControl(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            ctx.layoutNode.type === '$ref') {
+            return null;
+        }
+        return getControl(this.formGroup, this.getDataPointer(ctx));
+    }
+    getFormControlValue(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            ctx.layoutNode.type === '$ref') {
+            return null;
+        }
+        const control = getControl(this.formGroup, this.getDataPointer(ctx));
+        return control ? control.value : null;
+    }
+    getFormControlGroup(ctx) {
+        if (!ctx.layoutNode || !isDefined(ctx.layoutNode.dataPointer)) {
+            return null;
+        }
+        return getControl(this.formGroup, this.getDataPointer(ctx), true);
+    }
+    getFormControlName(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            !hasValue(ctx.dataIndex)) {
+            return null;
+        }
+        return JsonPointer.toKey(this.getDataPointer(ctx));
+    }
+    getLayoutArray(ctx) {
+        return JsonPointer.get(this.layout, this.getLayoutPointer(ctx), 0, -1);
+    }
+    getParentNode(ctx) {
+        return JsonPointer.get(this.layout, this.getLayoutPointer(ctx), 0, -2);
+    }
+    getDataPointer(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            !hasValue(ctx.dataIndex)) {
+            return null;
+        }
+        return JsonPointer.toIndexedPointer(ctx.layoutNode.dataPointer, ctx.dataIndex, this.arrayMap);
+    }
+    getLayoutPointer(ctx) {
+        if (!hasValue(ctx.layoutIndex)) {
+            return null;
+        }
+        return '/' + ctx.layoutIndex.join('/items/');
+    }
+    isControlBound(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            !hasValue(ctx.dataIndex)) {
+            return false;
+        }
+        const controlGroup = this.getFormControlGroup(ctx);
+        const name = this.getFormControlName(ctx);
+        return controlGroup ? hasOwn(controlGroup.controls, name) : false;
+    }
+    addItem(ctx, name) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.$ref) ||
+            !hasValue(ctx.dataIndex) ||
+            !hasValue(ctx.layoutIndex)) {
+            return false;
+        }
+        // Create a new Angular form control from a template in templateRefLibrary
+        const newFormGroup = buildFormGroup(this.templateRefLibrary[ctx.layoutNode.$ref]);
+        // Add the new form control to the parent formArray or formGroup
+        if (ctx.layoutNode.arrayItem) {
+            // Add new array item to formArray
+            this.getFormControlGroup(ctx).push(newFormGroup);
+        }
+        else {
+            // Add new $ref item to formGroup
+            this.getFormControlGroup(ctx).addControl(name || this.getFormControlName(ctx), newFormGroup);
+        }
+        // Copy a new layoutNode from layoutRefLibrary
+        const newLayoutNode = getLayoutNode(ctx.layoutNode, this);
+        newLayoutNode.arrayItem = ctx.layoutNode.arrayItem;
+        if (ctx.layoutNode.arrayItemType) {
+            newLayoutNode.arrayItemType = ctx.layoutNode.arrayItemType;
+        }
+        else {
+            delete newLayoutNode.arrayItemType;
+        }
+        if (name) {
+            newLayoutNode.name = name;
+            newLayoutNode.dataPointer += '/' + JsonPointer.escape(name);
+            newLayoutNode.options.title = fixTitle(name);
+        }
+        // Add the new layoutNode to the form layout
+        JsonPointer.insert(this.layout, this.getLayoutPointer(ctx), newLayoutNode);
+        return true;
+    }
+    moveArrayItem(ctx, oldIndex, newIndex) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            !hasValue(ctx.dataIndex) ||
+            !hasValue(ctx.layoutIndex) ||
+            !isDefined(oldIndex) ||
+            !isDefined(newIndex) ||
+            oldIndex === newIndex) {
+            return false;
+        }
+        // Move item in the formArray
+        const formArray = this.getFormControlGroup(ctx);
+        const arrayItem = formArray.at(oldIndex);
+        formArray.removeAt(oldIndex);
+        formArray.insert(newIndex, arrayItem);
+        formArray.updateValueAndValidity();
+        // Move layout item
+        const layoutArray = this.getLayoutArray(ctx);
+        layoutArray.splice(newIndex, 0, layoutArray.splice(oldIndex, 1)[0]);
+        return true;
+    }
+    removeItem(ctx) {
+        if (!ctx.layoutNode ||
+            !isDefined(ctx.layoutNode.dataPointer) ||
+            !hasValue(ctx.dataIndex) ||
+            !hasValue(ctx.layoutIndex)) {
+            return false;
+        }
+        // Remove the Angular form control from the parent formArray or formGroup
+        if (ctx.layoutNode.arrayItem) {
+            // Remove array item from formArray
+            this.getFormControlGroup(ctx).removeAt(ctx.dataIndex[ctx.dataIndex.length - 1]);
+        }
+        else {
+            // Remove $ref item from formGroup
+            this.getFormControlGroup(ctx).removeControl(this.getFormControlName(ctx));
+        }
+        // Remove layoutNode from layout
+        JsonPointer.remove(this.layout, this.getLayoutPointer(ctx));
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonSchemaFormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonSchemaFormService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonSchemaFormService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema-form.service.js","sourceRoot":"","sources":["../../../../../projects/ng-formworks-core/src/lib/json-schema-form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { AbstractControl, UntypedFormArray, UntypedFormGroup } from '@angular/forms';\r\n//import Ajv, { ErrorObject, Options } from 'ajv';\r\nimport Ajv2019, { ErrorObject, Options } from 'ajv/dist/2019';\r\n\r\nimport jsonDraft6 from 'ajv/lib/refs/json-schema-draft-06.json';\r\nimport jsonDraft7 from 'ajv/lib/refs/json-schema-draft-07.json';\r\nimport cloneDeep from 'lodash/cloneDeep';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport {\r\n  deValidationMessages,\r\n  enValidationMessages,\r\n  esValidationMessages,\r\n  frValidationMessages,\r\n  itValidationMessages,\r\n  ptValidationMessages,\r\n  zhValidationMessages\r\n} from './locale';\r\nimport {\r\n  JsonPointer,\r\n  buildFormGroup,\r\n  buildFormGroupTemplate,\r\n  buildLayout,\r\n  buildSchemaFromData,\r\n  buildSchemaFromLayout,\r\n  fixTitle,\r\n  forEach,\r\n  formatFormData,\r\n  getControl,\r\n  getLayoutNode,\r\n  hasOwn,\r\n  hasValue,\r\n  isArray,\r\n  isDefined,\r\n  isEmpty,\r\n  isObject,\r\n  removeRecursiveReferences,\r\n  toTitleCase\r\n} from './shared';\r\n\r\nimport _isEqual from 'lodash/isEqual';\r\n\r\n\r\nexport interface TitleMapItem {\r\n  name?: string;\r\n  value?: any;\r\n  checked?: boolean;\r\n  group?: string;\r\n  items?: TitleMapItem[];\r\n}\r\nexport interface ErrorMessages {\r\n  [control_name: string]: {\r\n    message: string | Function | Object;\r\n    code: string;\r\n  }[];\r\n}\r\n\r\n@Injectable()\r\nexport class JsonSchemaFormService implements OnDestroy {\r\n  JsonFormCompatibility = false;\r\n  ReactJsonSchemaFormCompatibility = false;\r\n  AngularSchemaFormCompatibility = false;\r\n  tpldata: any = {};\r\n\r\n  ajvOptions: Options = {\r\n    allErrors: true,\r\n    validateFormats:false,\r\n    strict:false\r\n  \r\n  };\r\n  ajv:any = new Ajv2019(this.ajvOptions); // AJV: Another JSON Schema Validator\r\n  \r\n  validateFormData: any = null; // Compiled AJV function to validate active form's schema\r\n\r\n  formValues: any = {}; // Internal form data (may not have correct types)\r\n  data: any = {}; // Output form data (formValues, formatted with correct data types)\r\n  schema: any = {}; // Internal JSON Schema\r\n  layout: any[] = []; // Internal form layout\r\n  formGroupTemplate: any = {}; // Template used to create formGroup\r\n  formGroup: any = null; // Angular formGroup, which powers the reactive form\r\n  framework: any = null; // Active framework component\r\n  formOptions: any; // Active options, used to configure the form\r\n\r\n  validData: any = null; // Valid form data (or null) (=== isValid ? data : null)\r\n  isValid: boolean = null; // Is current form data valid?\r\n  ajvErrors: ErrorObject[] = null; // Ajv errors for current data\r\n  validationErrors: any = null; // Any validation errors for current data\r\n  dataErrors: any = new Map(); //\r\n  formValueSubscription: any = null; // Subscription to formGroup.valueChanges observable (for un- and re-subscribing)\r\n  dataChanges: Subject<any> = new Subject(); // Form data observable\r\n  isValidChanges: Subject<any> = new Subject(); // isValid observable\r\n  validationErrorChanges: Subject<any> = new Subject(); // validationErrors observable\r\n\r\n  arrayMap: Map<string, number> = new Map(); // Maps arrays in data object and number of tuple values\r\n  dataMap: Map<string, any> = new Map(); // Maps paths in form data to schema and formGroup paths\r\n  dataRecursiveRefMap: Map<string, string> = new Map(); // Maps recursive reference points in form data\r\n  schemaRecursiveRefMap: Map<string, string> = new Map(); // Maps recursive reference points in schema\r\n  schemaRefLibrary: any = {}; // Library of schemas for resolving schema $refs\r\n  layoutRefLibrary: any = { '': null }; // Library of layout nodes for adding to form\r\n  templateRefLibrary: any = {}; // Library of formGroup templates for adding to form\r\n  hasRootReference = false; // Does the form include a recursive reference to itself?\r\n\r\n  language = 'en-US'; // Does the form include a recursive reference to itself?\r\n\r\n  // Default global form options\r\n  defaultFormOptions: any = {\r\n    autocomplete: true, // Allow the web browser to remember previous form submission values as defaults\r\n    addSubmit: 'auto', // Add a submit button if layout does not have one?\r\n    // for addSubmit: true = always, false = never,\r\n    // 'auto' = only if layout is undefined (form is built from schema alone)\r\n    debug: false, // Show debugging output?\r\n    disableInvalidSubmit: true, // Disable submit if form invalid?\r\n    formDisabled: false, // Set entire form as disabled? (not editable, and disables outputs)\r\n    formReadonly: false, // Set entire form as read only? (not editable, but outputs still enabled)\r\n    fieldsRequired: false, // (set automatically) Are there any required fields in the form?\r\n    framework: 'no-framework', // The framework to load\r\n    loadExternalAssets: false, // Load external css and JavaScript for framework?\r\n    pristine: { errors: true, success: true },\r\n    supressPropertyTitles: false,\r\n    setSchemaDefaults: 'auto', // Set fefault values from schema?\r\n    // true = always set (unless overridden by layout default or formValues)\r\n    // false = never set\r\n    // 'auto' = set in addable components, and everywhere if formValues not set\r\n    setLayoutDefaults: 'auto', // Set fefault values from layout?\r\n    // true = always set (unless overridden by formValues)\r\n    // false = never set\r\n    // 'auto' = set in addable components, and everywhere if formValues not set\r\n    validateOnRender: 'auto', // Validate fields immediately, before they are touched?\r\n    // true = validate all fields immediately\r\n    // false = only validate fields after they are touched by user\r\n    // 'auto' = validate fields with values immediately, empty fields after they are touched\r\n    widgets: {}, // Any custom widgets to load\r\n    defaultWidgetOptions: {\r\n      // Default options for form control widgets\r\n      listItems: 1, // Number of list items to initially add to arrays with no default value\r\n      addable: true, // Allow adding items to an array or $ref point?\r\n      orderable: true, // Allow reordering items within an array?\r\n      removable: true, // Allow removing items from an array or $ref point?\r\n      enableErrorState: true, // Apply 'has-error' class when field fails validation?\r\n      // disableErrorState: false, // Don't apply 'has-error' class when field fails validation?\r\n      enableSuccessState: true, // Apply 'has-success' class when field validates?\r\n      // disableSuccessState: false, // Don't apply 'has-success' class when field validates?\r\n      feedback: false, // Show inline feedback icons?\r\n      feedbackOnRender: false, // Show errorMessage on Render?\r\n      notitle: false, // Hide title?\r\n      disabled: false, // Set control as disabled? (not editable, and excluded from output)\r\n      readonly: false, // Set control as read only? (not editable, but included in output)\r\n      returnEmptyFields: true, // return values for fields that contain no data?\r\n      validationMessages: {} // set by setLanguage()\r\n    }\r\n  };\r\n\r\n  fcValueChangesSubs:Subscription;\r\n  fcStatusChangesSubs:Subscription;\r\n  constructor() {\r\n    this.setLanguage(this.language);\r\n    this.ajv.addMetaSchema(jsonDraft6);\r\n    this.ajv.addMetaSchema(jsonDraft7);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this.fcValueChangesSubs?.unsubscribe();\r\n    this.fcStatusChangesSubs?.unsubscribe();\r\n    this.formValueSubscription?.unsubscribe();\r\n    this.fcValueChangesSubs=null;\r\n    this.fcStatusChangesSubs=null;\r\n    this.formValueSubscription=null;\r\n\r\n  }\r\n\r\n  setLanguage(language: string = 'en-US') {\r\n    this.language = language;\r\n    const languageValidationMessages = {\r\n      de: deValidationMessages,\r\n      en: enValidationMessages,\r\n      es: esValidationMessages,\r\n      fr: frValidationMessages,\r\n      it: itValidationMessages,\r\n      pt: ptValidationMessages,\r\n      zh: zhValidationMessages,\r\n    };\r\n    const languageCode = language.slice(0, 2);\r\n\r\n    const validationMessages = languageValidationMessages[languageCode];\r\n\r\n    this.defaultFormOptions.defaultWidgetOptions.validationMessages = cloneDeep(\r\n      validationMessages\r\n    );\r\n  }\r\n\r\n  getData() {\r\n    return this.data;\r\n  }\r\n\r\n  getSchema() {\r\n    return this.schema;\r\n  }\r\n\r\n  getLayout() {\r\n    return this.layout;\r\n  }\r\n\r\n  resetAllValues() {\r\n    this.JsonFormCompatibility = false;\r\n    this.ReactJsonSchemaFormCompatibility = false;\r\n    this.AngularSchemaFormCompatibility = false;\r\n    this.tpldata = {};\r\n    this.validateFormData = null;\r\n    this.formValues = {};\r\n    this.schema = {};\r\n    this.layout = [];\r\n    this.formGroupTemplate = {};\r\n    this.formGroup = null;\r\n    this.framework = null;\r\n    this.data = {};\r\n    this.validData = null;\r\n    this.isValid = null;\r\n    this.validationErrors = null;\r\n    this.arrayMap = new Map();\r\n    this.dataMap = new Map();\r\n    this.dataRecursiveRefMap = new Map();\r\n    this.schemaRecursiveRefMap = new Map();\r\n    this.layoutRefLibrary = {};\r\n    this.schemaRefLibrary = {};\r\n    this.templateRefLibrary = {};\r\n    this.formOptions = cloneDeep(this.defaultFormOptions);\r\n  }\r\n\r\n  /**\r\n   * 'buildRemoteError' function\r\n   *\r\n   * Example errors:\r\n   * {\r\n   *   last_name: [ {\r\n   *     message: 'Last name must by start with capital letter.',\r\n   *     code: 'capital_letter'\r\n   *   } ],\r\n   *   email: [ {\r\n   *     message: 'Email must be from example.com domain.',\r\n   *     code: 'special_domain'\r\n   *   }, {\r\n   *     message: 'Email must contain an @ symbol.',\r\n   *     code: 'at_symbol'\r\n   *   } ]\r\n   * }\r\n   * //{ErrorMessages} errors\r\n   */\r\n  buildRemoteError(errors: ErrorMessages) {\r\n    forEach(errors, (value, key) => {\r\n      if (key in this.formGroup.controls) {\r\n        for (const error of value) {\r\n          const err = {};\r\n          err[error['code']] = error['message'];\r\n          this.formGroup.get(key).setErrors(err, { emitEvent: true });\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  validateData(newValue: any, updateSubscriptions = true): void {\r\n    // Format raw form data to correct data types\r\n    this.data = formatFormData(\r\n      newValue,\r\n      this.dataMap,\r\n      this.dataRecursiveRefMap,\r\n      this.arrayMap,\r\n      this.formOptions.returnEmptyFields\r\n    );\r\n    this.isValid = this.validateFormData(this.data);\r\n    this.validData = this.isValid ? this.data : null;\r\n    const compileErrors = (errors:ErrorObject[]) => {\r\n      const compiledErrors = {};\r\n      (errors || []).forEach(error => {\r\n        //TODO review-seems to be a change in newer versions\r\n        //of ajv giving '' as instancePath for root objects\r\n        let errorPath=error.instancePath||\"ROOT\";\r\n        if (!compiledErrors[errorPath]) {\r\n          compiledErrors[errorPath] = [];\r\n        }\r\n        compiledErrors[errorPath].push(error.message);\r\n      });\r\n      return compiledErrors;\r\n    };\r\n    this.ajvErrors = this.validateFormData.errors;\r\n    this.validationErrors = compileErrors(this.validateFormData.errors);\r\n    if (updateSubscriptions) {\r\n      this.dataChanges.next(this.data);\r\n      this.isValidChanges.next(this.isValid);\r\n      this.validationErrorChanges.next(this.ajvErrors);\r\n    }\r\n  }\r\n\r\n  buildFormGroupTemplate(formValues: any = null, setValues = true) {\r\n    this.formGroupTemplate = buildFormGroupTemplate(\r\n      this,\r\n      formValues,\r\n      setValues\r\n    );\r\n  }\r\n\r\n  buildFormGroup() {\r\n    this.formGroup = <UntypedFormGroup>buildFormGroup(this.formGroupTemplate);\r\n    if (this.formGroup) {\r\n      this.compileAjvSchema();\r\n      this.validateData(this.formGroup.value);\r\n\r\n      // Set up observables to emit data and validation info when form data changes\r\n      if (this.formValueSubscription) {\r\n        this.formValueSubscription.unsubscribe();\r\n      }\r\n      this.formValueSubscription = this.formGroup.valueChanges.subscribe(\r\n        formValue => this.validateData(formValue)\r\n      );\r\n    }\r\n  }\r\n\r\n  buildLayout(widgetLibrary: any) {\r\n    this.layout = buildLayout(this, widgetLibrary);\r\n  }\r\n\r\n  setOptions(newOptions: any) {\r\n    if (isObject(newOptions)) {\r\n      const addOptions = cloneDeep(newOptions);\r\n      // Backward compatibility for 'defaultOptions' (renamed 'defaultWidgetOptions')\r\n      if (isObject(addOptions.defaultOptions)) {\r\n        Object.assign(\r\n          this.formOptions.defaultWidgetOptions,\r\n          addOptions.defaultOptions\r\n        );\r\n        delete addOptions.defaultOptions;\r\n      }\r\n      if (isObject(addOptions.defaultWidgetOptions)) {\r\n        Object.assign(\r\n          this.formOptions.defaultWidgetOptions,\r\n          addOptions.defaultWidgetOptions\r\n        );\r\n        delete addOptions.defaultWidgetOptions;\r\n      }\r\n      Object.assign(this.formOptions, addOptions);\r\n\r\n      // convert disableErrorState / disableSuccessState to enable...\r\n      const globalDefaults = this.formOptions.defaultWidgetOptions;\r\n      ['ErrorState', 'SuccessState']\r\n        .filter(suffix => hasOwn(globalDefaults, 'disable' + suffix))\r\n        .forEach(suffix => {\r\n          globalDefaults['enable' + suffix] = !globalDefaults[\r\n            'disable' + suffix\r\n          ];\r\n          delete globalDefaults['disable' + suffix];\r\n        });\r\n    }\r\n  }\r\n\r\n  compileAjvSchema() {\r\n    if (!this.validateFormData) {\r\n      // if 'ui:order' exists in properties, move it to root before compiling with ajv\r\n      if (Array.isArray(this.schema.properties['ui:order'])) {\r\n        this.schema['ui:order'] = this.schema.properties['ui:order'];\r\n        delete this.schema.properties['ui:order'];\r\n      }\r\n      this.ajv.removeSchema(this.schema);\r\n      this.validateFormData = this.ajv.compile(this.schema);\r\n    }\r\n  }\r\n\r\n  buildSchemaFromData(data?: any, requireAllFields = false): any {\r\n    if (data) {\r\n      return buildSchemaFromData(data, requireAllFields);\r\n    }\r\n    this.schema = buildSchemaFromData(this.formValues, requireAllFields);\r\n  }\r\n\r\n  buildSchemaFromLayout(layout?: any): any {\r\n    if (layout) {\r\n      return buildSchemaFromLayout(layout);\r\n    }\r\n    this.schema = buildSchemaFromLayout(this.layout);\r\n  }\r\n\r\n  setTpldata(newTpldata: any = {}): void {\r\n    this.tpldata = newTpldata;\r\n  }\r\n\r\n  parseText(\r\n    text = '',\r\n    value: any = {},\r\n    values: any = {},\r\n    key: number | string = null\r\n  ): string {\r\n    if (!text || !/{{.+?}}/.test(text)) {\r\n      return text;\r\n    }\r\n    return text.replace(/{{(.+?)}}/g, (...a) =>\r\n      this.parseExpression(a[1], value, values, key, this.tpldata)\r\n    );\r\n  }\r\n\r\n  parseExpression(\r\n    expression = '',\r\n    value: any = {},\r\n    values: any = {},\r\n    key: number | string = null,\r\n    tpldata: any = null\r\n  ) {\r\n    if (typeof expression !== 'string') {\r\n      return '';\r\n    }\r\n    const index = typeof key === 'number' ? key + 1 + '' : key || '';\r\n    expression = expression.trim();\r\n    if (\r\n      (expression[0] === \"'\" || expression[0] === '\"') &&\r\n      expression[0] === expression[expression.length - 1] &&\r\n      expression.slice(1, expression.length - 1).indexOf(expression[0]) === -1\r\n    ) {\r\n      return expression.slice(1, expression.length - 1);\r\n    }\r\n    if (expression === 'idx' || expression === '$index') {\r\n      return index;\r\n    }\r\n    if (expression === 'value' && !hasOwn(values, 'value')) {\r\n      return value;\r\n    }\r\n    if (\r\n      ['\"', \"'\", ' ', '||', '&&', '+'].every(\r\n        delim => expression.indexOf(delim) === -1\r\n      )\r\n    ) {\r\n      const pointer = JsonPointer.parseObjectPath(expression);\r\n      return pointer[0] === 'value' && JsonPointer.has(value, pointer.slice(1))\r\n        ? JsonPointer.get(value, pointer.slice(1))\r\n        : pointer[0] === 'values' && JsonPointer.has(values, pointer.slice(1))\r\n          ? JsonPointer.get(values, pointer.slice(1))\r\n          : pointer[0] === 'tpldata' && JsonPointer.has(tpldata, pointer.slice(1))\r\n            ? JsonPointer.get(tpldata, pointer.slice(1))\r\n            : JsonPointer.has(values, pointer)\r\n              ? JsonPointer.get(values, pointer)\r\n              : '';\r\n    }\r\n    if (expression.indexOf('[idx]') > -1) {\r\n      expression = expression.replace(/\\[idx\\]/g, <string>index);\r\n    }\r\n    if (expression.indexOf('[$index]') > -1) {\r\n      expression = expression.replace(/\\[$index\\]/g, <string>index);\r\n    }\r\n    // TODO: Improve expression evaluation by parsing quoted strings first\r\n    // let expressionArray = expression.match(/([^\"']+|\"[^\"]+\"|'[^']+')/g);\r\n    if (expression.indexOf('||') > -1) {\r\n      return expression\r\n        .split('||')\r\n        .reduce(\r\n          (all, term) =>\r\n            all || this.parseExpression(term, value, values, key, tpldata),\r\n          ''\r\n        );\r\n    }\r\n    if (expression.indexOf('&&') > -1) {\r\n      return expression\r\n        .split('&&')\r\n        .reduce(\r\n          (all, term) =>\r\n            all && this.parseExpression(term, value, values, key, tpldata),\r\n          ' '\r\n        )\r\n        .trim();\r\n    }\r\n    if (expression.indexOf('+') > -1) {\r\n      return expression\r\n        .split('+')\r\n        .map(term => this.parseExpression(term, value, values, key, tpldata))\r\n        .join('');\r\n    }\r\n    return '';\r\n  }\r\n\r\n  setArrayItemTitle(\r\n    parentCtx: any = {},\r\n    childNode: any = null,\r\n    index: number = null\r\n  ): string {\r\n    const parentNode = parentCtx.layoutNode;\r\n    const parentValues: any = this.getFormControlValue(parentCtx);\r\n    const isArrayItem =\r\n      (parentNode.type || '').slice(-5) === 'array' && isArray(parentValues);\r\n    const text = JsonPointer.getFirst(\r\n      isArrayItem && childNode.type !== '$ref'\r\n        ? [\r\n          [childNode, '/options/legend'],\r\n          [childNode, '/options/title'],\r\n          [parentNode, '/options/title'],\r\n          [parentNode, '/options/legend']\r\n        ]\r\n        : [\r\n          [childNode, '/options/title'],\r\n          [childNode, '/options/legend'],\r\n          [parentNode, '/options/title'],\r\n          [parentNode, '/options/legend']\r\n        ]\r\n    );\r\n    if (!text) {\r\n      return text;\r\n    }\r\n    const childValue =\r\n      isArray(parentValues) && index < parentValues.length\r\n        ? parentValues[index]\r\n        : parentValues;\r\n    return this.parseText(text, childValue, parentValues, index);\r\n  }\r\n\r\n  setItemTitle(ctx: any) {\r\n    return !ctx.options.title && /^(\\d+|-)$/.test(ctx.layoutNode.name)\r\n      ? null\r\n      : this.parseText(\r\n        ctx.options.title || toTitleCase(ctx.layoutNode.name),\r\n        this.getFormControlValue(this),\r\n        (this.getFormControlGroup(this) || <any>{}).value,\r\n        ctx.dataIndex[ctx.dataIndex.length - 1]\r\n      );\r\n  }\r\n\r\n  evaluateCondition(layoutNode: any, dataIndex: number[]): boolean {\r\n    const arrayIndex = dataIndex && dataIndex[dataIndex.length - 1];\r\n    let result = true;\r\n    if (hasValue((layoutNode.options || {}).condition)) {\r\n      if (typeof layoutNode.options.condition === 'string') {\r\n        let pointer = layoutNode.options.condition;\r\n        if (hasValue(arrayIndex)) {\r\n          pointer = pointer.replace('[arrayIndex]', `[${arrayIndex}]`);\r\n        }\r\n        pointer = JsonPointer.parseObjectPath(pointer);\r\n        result = !!JsonPointer.get(this.data, pointer);\r\n        if (!result && pointer[0] === 'model') {\r\n          result = !!JsonPointer.get({ model: this.data }, pointer);\r\n        }\r\n      } else if (typeof layoutNode.options.condition === 'function') {\r\n        result = layoutNode.options.condition(this.data);\r\n      } else if (\r\n        typeof layoutNode.options.condition.functionBody === 'string'\r\n      ) {\r\n        try {\r\n          const dynFn = new Function(\r\n            'model',\r\n            'arrayIndices',\r\n            layoutNode.options.condition.functionBody\r\n          );\r\n          result = dynFn(this.data, dataIndex);\r\n        } catch (e) {\r\n          result = true;\r\n          console.error(\r\n            'condition functionBody errored out on evaluation: ' +\r\n            layoutNode.options.condition.functionBody\r\n          );\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  initializeControl(ctx: any, bind = true): boolean {\r\n    if (!isObject(ctx)) {\r\n      return false;\r\n    }\r\n    if (isEmpty(ctx.options)) {\r\n      ctx.options = !isEmpty((ctx.layoutNode || {}).options)\r\n        ? ctx.layoutNode.options\r\n        : cloneDeep(this.formOptions);\r\n    }\r\n    ctx.formControl = this.getFormControl(ctx);\r\n    ctx.boundControl = bind && !!ctx.formControl;\r\n    if (ctx.formControl) {\r\n      ctx.controlName = this.getFormControlName(ctx);\r\n      ctx.controlValue = ctx.formControl.value;\r\n      ctx.controlDisabled = ctx.formControl.disabled;\r\n      ctx.options.errorMessage =\r\n        ctx.formControl.status === 'VALID'\r\n          ? null\r\n          : this.formatErrors(\r\n            ctx.formControl.errors,\r\n            ctx.options.validationMessages\r\n          );\r\n      ctx.options.showErrors =\r\n        this.formOptions.validateOnRender === true ||\r\n        (this.formOptions.validateOnRender === 'auto' &&\r\n          hasValue(ctx.controlValue));\r\n      this.fcStatusChangesSubs=ctx.formControl.statusChanges.subscribe(\r\n        status =>\r\n          (ctx.options.errorMessage =\r\n            status === 'VALID'\r\n              ? null\r\n              : this.formatErrors(\r\n                ctx.formControl.errors,\r\n                ctx.options.validationMessages\r\n              ))\r\n      );\r\n      this.fcValueChangesSubs=ctx.formControl.valueChanges.subscribe(value => {\r\n         //commented out to revert back to previous commits\r\n         //as seems to be causing some issues\r\n         /*\r\n        if (!!value) {\r\n          ctx.controlValue = value;\r\n        }\r\n        */\r\n        //TODO-test,this is the original code\r\n        if (!_isEqual(ctx.controlValue, value)) { ctx.controlValue = value }\r\n      });\r\n    } else {\r\n      ctx.controlName = ctx.layoutNode.name;\r\n      ctx.controlValue = ctx.layoutNode.value || null;\r\n      const dataPointer = this.getDataPointer(ctx);\r\n      if (bind && dataPointer) {\r\n        console.error(\r\n          `warning: control \"${dataPointer}\" is not bound to the Angular FormGroup.`\r\n        );\r\n      }\r\n    }\r\n    return ctx.boundControl;\r\n  }\r\n\r\n  formatErrors(errors: any, validationMessages: any = {}): string {\r\n    if (isEmpty(errors)) {\r\n      return null;\r\n    }\r\n    if (!isObject(validationMessages)) {\r\n      validationMessages = {};\r\n    }\r\n    const addSpaces = string =>\r\n      string[0].toUpperCase() +\r\n      (string.slice(1) || '')\r\n        .replace(/([a-z])([A-Z])/g, '$1 $2')\r\n        .replace(/_/g, ' ');\r\n    const formatError = error =>\r\n      typeof error === 'object'\r\n        ? Object.keys(error)\r\n          .map(key =>\r\n            error[key] === true\r\n              ? addSpaces(key)\r\n              : error[key] === false\r\n                ? 'Not ' + addSpaces(key)\r\n                : addSpaces(key) + ': ' + formatError(error[key])\r\n          )\r\n          .join(', ')\r\n        : addSpaces(error.toString());\r\n    const messages = [];\r\n    return (\r\n      Object.keys(errors)\r\n        // Hide 'required' error, unless it is the only one\r\n        .filter(\r\n          errorKey =>\r\n            errorKey !== 'required' || Object.keys(errors).length === 1\r\n        )\r\n        .map(errorKey =>\r\n          // If validationMessages is a string, return it\r\n          typeof validationMessages === 'string'\r\n            ? validationMessages\r\n            : // If custom error message is a function, return function result\r\n            typeof validationMessages[errorKey] === 'function'\r\n              ? validationMessages[errorKey](errors[errorKey])\r\n              : // If custom error message is a string, replace placeholders and return\r\n              typeof validationMessages[errorKey] === 'string'\r\n                ? // Does error message have any {{property}} placeholders?\r\n                !/{{.+?}}/.test(validationMessages[errorKey])\r\n                  ? validationMessages[errorKey]\r\n                  : // Replace {{property}} placeholders with values\r\n                  Object.keys(errors[errorKey]).reduce(\r\n                    (errorMessage, errorProperty) =>\r\n                      errorMessage.replace(\r\n                        new RegExp('{{' + errorProperty + '}}', 'g'),\r\n                        errors[errorKey][errorProperty]\r\n                      ),\r\n                    validationMessages[errorKey]\r\n                  )\r\n                : // If no custom error message, return formatted error data instead\r\n                addSpaces(errorKey) + ' Error: ' + formatError(errors[errorKey])\r\n        )\r\n        .join('<br>')\r\n    );\r\n  }\r\n\r\n  updateValue(ctx: any, value: any): void {\r\n    // Set value of current control\r\n    ctx.controlValue = value;\r\n    if (ctx.boundControl) {\r\n      ctx.formControl.setValue(value);\r\n      ctx.formControl.markAsDirty();\r\n    }\r\n    ctx.layoutNode.value = value;\r\n\r\n    // Set values of any related controls in copyValueTo array\r\n    if (isArray(ctx.options.copyValueTo)) {\r\n      for (const item of ctx.options.copyValueTo) {\r\n        const targetControl = getControl(this.formGroup, item);\r\n        if (\r\n          isObject(targetControl) &&\r\n          typeof targetControl.setValue === 'function'\r\n        ) {\r\n          targetControl.setValue(value);\r\n          targetControl.markAsDirty();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  updateArrayCheckboxList(ctx: any, checkboxList: TitleMapItem[]): void {\r\n    const formArray = <UntypedFormArray>this.getFormControl(ctx);\r\n\r\n    // Remove all existing items\r\n    while (formArray.value.length) {\r\n      formArray.removeAt(0);\r\n    }\r\n\r\n    // Re-add an item for each checked box\r\n    const refPointer = removeRecursiveReferences(\r\n      ctx.layoutNode.dataPointer + '/-',\r\n      this.dataRecursiveRefMap,\r\n      this.arrayMap\r\n    );\r\n    for (const checkboxItem of checkboxList) {\r\n      if (checkboxItem.checked) {\r\n        const newFormControl = buildFormGroup(\r\n          this.templateRefLibrary[refPointer]\r\n        );\r\n        newFormControl.setValue(checkboxItem.value);\r\n        formArray.push(newFormControl);\r\n      }\r\n    }\r\n    formArray.markAsDirty();\r\n  }\r\n\r\n  getFormControl(ctx: any): AbstractControl {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      ctx.layoutNode.type === '$ref'\r\n    ) {\r\n      return null;\r\n    }\r\n    return getControl(this.formGroup, this.getDataPointer(ctx));\r\n  }\r\n\r\n  getFormControlValue(ctx: any): AbstractControl {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      ctx.layoutNode.type === '$ref'\r\n    ) {\r\n      return null;\r\n    }\r\n    const control = getControl(this.formGroup, this.getDataPointer(ctx));\r\n    return control ? control.value : null;\r\n  }\r\n\r\n  getFormControlGroup(ctx: any): UntypedFormArray | UntypedFormGroup {\r\n    if (!ctx.layoutNode || !isDefined(ctx.layoutNode.dataPointer)) {\r\n      return null;\r\n    }\r\n    return getControl(this.formGroup, this.getDataPointer(ctx), true);\r\n  }\r\n\r\n  getFormControlName(ctx: any): string {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      !hasValue(ctx.dataIndex)\r\n    ) {\r\n      return null;\r\n    }\r\n    return JsonPointer.toKey(this.getDataPointer(ctx));\r\n  }\r\n\r\n  getLayoutArray(ctx: any): any[] {\r\n    return JsonPointer.get(this.layout, this.getLayoutPointer(ctx), 0, -1);\r\n  }\r\n\r\n  getParentNode(ctx: any): any {\r\n    return JsonPointer.get(this.layout, this.getLayoutPointer(ctx), 0, -2);\r\n  }\r\n\r\n  getDataPointer(ctx: any): string {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      !hasValue(ctx.dataIndex)\r\n    ) {\r\n      return null;\r\n    }\r\n    return JsonPointer.toIndexedPointer(\r\n      ctx.layoutNode.dataPointer,\r\n      ctx.dataIndex,\r\n      this.arrayMap\r\n    );\r\n  }\r\n\r\n  getLayoutPointer(ctx: any): string {\r\n    if (!hasValue(ctx.layoutIndex)) {\r\n      return null;\r\n    }\r\n    return '/' + ctx.layoutIndex.join('/items/');\r\n  }\r\n\r\n  isControlBound(ctx: any): boolean {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      !hasValue(ctx.dataIndex)\r\n    ) {\r\n      return false;\r\n    }\r\n    const controlGroup = this.getFormControlGroup(ctx);\r\n    const name = this.getFormControlName(ctx);\r\n    return controlGroup ? hasOwn(controlGroup.controls, name) : false;\r\n  }\r\n\r\n  addItem(ctx: any, name?: string): boolean {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.$ref) ||\r\n      !hasValue(ctx.dataIndex) ||\r\n      !hasValue(ctx.layoutIndex)\r\n    ) {\r\n      return false;\r\n    }\r\n\r\n    // Create a new Angular form control from a template in templateRefLibrary\r\n    const newFormGroup = buildFormGroup(\r\n      this.templateRefLibrary[ctx.layoutNode.$ref]\r\n    );\r\n\r\n    // Add the new form control to the parent formArray or formGroup\r\n    if (ctx.layoutNode.arrayItem) {\r\n      // Add new array item to formArray\r\n      (<UntypedFormArray>this.getFormControlGroup(ctx)).push(newFormGroup);\r\n    } else {\r\n      // Add new $ref item to formGroup\r\n      (<UntypedFormGroup>this.getFormControlGroup(ctx)).addControl(\r\n        name || this.getFormControlName(ctx),\r\n        newFormGroup\r\n      );\r\n    }\r\n\r\n    // Copy a new layoutNode from layoutRefLibrary\r\n    const newLayoutNode = getLayoutNode(ctx.layoutNode, this);\r\n    newLayoutNode.arrayItem = ctx.layoutNode.arrayItem;\r\n    if (ctx.layoutNode.arrayItemType) {\r\n      newLayoutNode.arrayItemType = ctx.layoutNode.arrayItemType;\r\n    } else {\r\n      delete newLayoutNode.arrayItemType;\r\n    }\r\n    if (name) {\r\n      newLayoutNode.name = name;\r\n      newLayoutNode.dataPointer += '/' + JsonPointer.escape(name);\r\n      newLayoutNode.options.title = fixTitle(name);\r\n    }\r\n\r\n    // Add the new layoutNode to the form layout\r\n    JsonPointer.insert(this.layout, this.getLayoutPointer(ctx), newLayoutNode);\r\n\r\n    return true;\r\n  }\r\n\r\n  moveArrayItem(ctx: any, oldIndex: number, newIndex: number): boolean {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      !hasValue(ctx.dataIndex) ||\r\n      !hasValue(ctx.layoutIndex) ||\r\n      !isDefined(oldIndex) ||\r\n      !isDefined(newIndex) ||\r\n      oldIndex === newIndex\r\n    ) {\r\n      return false;\r\n    }\r\n\r\n    // Move item in the formArray\r\n    const formArray = <UntypedFormArray>this.getFormControlGroup(ctx);\r\n    const arrayItem = formArray.at(oldIndex);\r\n    formArray.removeAt(oldIndex);\r\n    formArray.insert(newIndex, arrayItem);\r\n    formArray.updateValueAndValidity();\r\n\r\n    // Move layout item\r\n    const layoutArray = this.getLayoutArray(ctx);\r\n    layoutArray.splice(newIndex, 0, layoutArray.splice(oldIndex, 1)[0]);\r\n    return true;\r\n  }\r\n\r\n  removeItem(ctx: any): boolean {\r\n    if (\r\n      !ctx.layoutNode ||\r\n      !isDefined(ctx.layoutNode.dataPointer) ||\r\n      !hasValue(ctx.dataIndex) ||\r\n      !hasValue(ctx.layoutIndex)\r\n    ) {\r\n      return false;\r\n    }\r\n\r\n    // Remove the Angular form control from the parent formArray or formGroup\r\n    if (ctx.layoutNode.arrayItem) {\r\n      // Remove array item from formArray\r\n      (<UntypedFormArray>this.getFormControlGroup(ctx)).removeAt(\r\n        ctx.dataIndex[ctx.dataIndex.length - 1]\r\n      );\r\n    } else {\r\n      // Remove $ref item from formGroup\r\n      (<UntypedFormGroup>this.getFormControlGroup(ctx)).removeControl(\r\n        this.getFormControlName(ctx)\r\n      );\r\n    }\r\n\r\n    // Remove layoutNode from layout\r\n    JsonPointer.remove(this.layout, this.getLayoutPointer(ctx));\r\n    return true;\r\n  }\r\n}\r\n"]}