@ng-formworks/core 17.2.7 → 17.3.0

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

@@ -0,0 +1,765 @@
+import cloneDeep from 'lodash/cloneDeep';
+import isEqual from 'lodash/isEqual';
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Input, Output, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { JsonSchemaFormService } from './json-schema-form.service';
+import { convertSchemaToDraft6 } from './shared/convert-schema-to-draft6.function';
+import { resolveSchemaReferences } from './shared/json-schema.functions';
+import { JsonPointer } from './shared/jsonpointer.functions';
+import { forEach, hasOwn } from './shared/utility.functions';
+import { hasValue, inArray, isArray, isEmpty, isObject } from './shared/validator.functions';
+import * as i0 from "@angular/core";
+import * as i1 from "./framework-library/framework-library.service";
+import * as i2 from "./widget-library/widget-library.service";
+import * as i3 from "./json-schema-form.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "./widget-library/root.component";
+export const JSON_SCHEMA_FORM_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => JsonSchemaFormComponent),
+    multi: true,
+};
+/**
+ * @module 'JsonSchemaFormComponent' - Angular JSON Schema Form
+ *
+ * Root module of the Angular JSON Schema Form client-side library,
+ * an Angular library which generates an HTML form from a JSON schema
+ * structured data model and/or a JSON Schema Form layout description.
+ *
+ * This library also validates input data by the user, using both validators on
+ * individual controls to provide real-time feedback while the user is filling
+ * out the form, and then validating the entire input against the schema when
+ * the form is submitted to make sure the returned JSON data object is valid.
+ *
+ * This library is similar to, and mostly API compatible with:
+ *
+ * - JSON Schema Form's Angular Schema Form library for AngularJs
+ *   http://schemaform.io
+ *   http://schemaform.io/examples/bootstrap-example.html (examples)
+ *
+ * - Mozilla's react-jsonschema-form library for React
+ *   https://github.com/mozilla-services/react-jsonschema-form
+ *   https://mozilla-services.github.io/react-jsonschema-form (examples)
+ *
+ * - Joshfire's JSON Form library for jQuery
+ *   https://github.com/joshfire/jsonform
+ *   http://ulion.github.io/jsonform/playground (examples)
+ *
+ * This library depends on:
+ *  - Angular (obviously)                  https://angular.io
+ *  - lodash, JavaScript utility library   https://github.com/lodash/lodash
+ *  - ajv, Another JSON Schema validator   https://github.com/epoberezkin/ajv
+ *
+ * In addition, the Example Playground also depends on:
+ *  - brace, Browserified Ace editor       http://thlorenz.github.io/brace
+ */
+export class JsonSchemaFormComponent {
+    get value() {
+        return this.objectWrap ? this.jsf.data['1'] : this.jsf.data;
+    }
+    set value(value) {
+        this.setFormValues(value, false);
+    }
+    constructor(changeDetector, frameworkLibrary, widgetLibrary, jsf) {
+        this.changeDetector = changeDetector;
+        this.frameworkLibrary = frameworkLibrary;
+        this.widgetLibrary = widgetLibrary;
+        this.jsf = jsf;
+        // TODO: quickfix to avoid subscribing twice to the same emitters
+        this.unsubscribeOnActivateForm$ = new Subject();
+        this.formValueSubscription = null;
+        this.formInitialized = false;
+        this.objectWrap = false; // Is non-object input schema wrapped in an object?
+        this.previousInputs = {
+            schema: null, layout: null, data: null, options: null, framework: null,
+            widgets: null, form: null, model: null, JSONSchema: null, UISchema: null,
+            formData: null, loadExternalAssets: null, debug: null,
+        };
+        // Outputs
+        this.onChanges = new EventEmitter(); // Live unvalidated internal form data
+        this.onSubmit = new EventEmitter(); // Complete validated form data
+        this.isValid = new EventEmitter(); // Is current data valid?
+        this.validationErrors = new EventEmitter(); // Validation errors (if any)
+        this.formSchema = new EventEmitter(); // Final schema used to create form
+        this.formLayout = new EventEmitter(); // Final layout used to create form
+        // Outputs for possible 2-way data binding
+        // Only the one input providing the initial form data will be bound.
+        // If there is no inital data, input '{}' to activate 2-way data binding.
+        // There is no 2-way binding if inital data is combined inside the 'form' input.
+        this.dataChange = new EventEmitter();
+        this.modelChange = new EventEmitter();
+        this.formDataChange = new EventEmitter();
+        this.ngModelChange = new EventEmitter();
+    }
+    ngOnDestroy() {
+        this.dataChangesSubs?.unsubscribe();
+        this.statusChangesSubs?.unsubscribe();
+        this.isValidChangesSubs?.unsubscribe();
+        this.validationErrorChangesSubs?.unsubscribe();
+        this.dataChangesSubs = null;
+        this.statusChangesSubs = null;
+        this.isValidChangesSubs = null;
+        this.validationErrorChangesSubs = null;
+    }
+    resetScriptsAndStyleSheets() {
+        document.querySelectorAll('.ajsf').forEach(element => element.remove());
+    }
+    loadScripts(scriptList) {
+        const scripts = scriptList || this.frameworkLibrary.getFrameworkScripts();
+        scripts.map(script => {
+            const scriptTag = document.createElement('script');
+            scriptTag.src = script;
+            scriptTag.type = 'text/javascript';
+            scriptTag.async = true;
+            scriptTag.setAttribute('class', 'ajsf');
+            document.getElementsByTagName('head')[0].appendChild(scriptTag);
+        });
+    }
+    loadStyleSheets(styleList) {
+        const stylesheets = styleList || this.frameworkLibrary.getFrameworkStylesheets();
+        stylesheets.map(stylesheet => {
+            const linkTag = document.createElement('link');
+            linkTag.rel = 'stylesheet';
+            linkTag.href = stylesheet;
+            linkTag.setAttribute('class', 'ajsf');
+            document.getElementsByTagName('head')[0].appendChild(linkTag);
+        });
+    }
+    loadAssets() {
+        this.frameworkLibrary.getFrameworkAssetConfig().then(assetCfg => {
+            this.resetScriptsAndStyleSheets();
+            this.loadScripts(assetCfg.scripts);
+            this.loadStyleSheets(assetCfg.stylesheets);
+        }).catch(err => {
+            console.log(err);
+            this.resetScriptsAndStyleSheets();
+            this.loadScripts();
+            this.loadStyleSheets();
+        });
+    }
+    ngOnInit() {
+        this.updateForm();
+        this.loadAssets();
+    }
+    ngOnChanges(changes) {
+        this.updateForm();
+        // Check if there's changes in Framework then load assets if that's the
+        if (changes.framework) {
+            if (!changes.framework.isFirstChange() &&
+                (changes.framework.previousValue !== changes.framework.currentValue)) {
+                this.loadAssets();
+            }
+        }
+    }
+    writeValue(value) {
+        this.setFormValues(value, false);
+        if (!this.formValuesInput) {
+            this.formValuesInput = 'ngModel';
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    //see note
+    //https://angular.io/guide/update-to-version-15#v15-bc-06
+    setDisabledState(isDisabled) {
+        if (this.jsf.formOptions.formDisabled !== !!isDisabled) {
+            this.jsf.formOptions.formDisabled = !!isDisabled;
+            this.initializeForm();
+        }
+    }
+    updateForm() {
+        let changedData;
+        if (!this.formInitialized || !this.formValuesInput ||
+            (this.language && this.language !== this.jsf.language)) {
+            this.initializeForm();
+        }
+        else {
+            if (this.language && this.language !== this.jsf.language) {
+                this.jsf.setLanguage(this.language);
+            }
+            // Get names of changed inputs
+            let changedInput = Object.keys(this.previousInputs)
+                .filter(input => this.previousInputs[input] !== this[input]);
+            let resetFirst = true;
+            if (changedInput.length === 1 && changedInput[0] === 'form' &&
+                this.formValuesInput.startsWith('form.')) {
+                // If only 'form' input changed, get names of changed keys
+                changedInput = Object.keys(this.previousInputs.form || {})
+                    .filter(key => !isEqual(this.previousInputs.form[key], this.form[key]))
+                    .map(key => `form.${key}`);
+                resetFirst = false;
+            }
+            // If only input values have changed, update the form values
+            if (changedInput.length === 1 && changedInput[0] === this.formValuesInput) {
+                if (this.formValuesInput.indexOf('.') === -1) {
+                    changedData = this[this.formValuesInput];
+                    this.setFormValues(changedData, resetFirst);
+                }
+                else {
+                    const [input, key] = this.formValuesInput.split('.');
+                    changedData = this[input][key];
+                    this.setFormValues(changedData, resetFirst);
+                }
+                // If anything else has changed, re-render the entire form
+            }
+            else if (changedInput.length) {
+                this.initializeForm(changedData);
+                if (this.onChange) {
+                    this.onChange(this.jsf.formValues);
+                }
+                if (this.onTouched) {
+                    this.onTouched(this.jsf.formValues);
+                }
+            }
+            //set framework theme
+            if (this.theme && this.theme !== this.frameworkLibrary.getActiveTheme()?.name) {
+                this.frameworkLibrary.requestThemeChange(this.theme);
+            }
+            // Update previous inputs
+            Object.keys(this.previousInputs)
+                .filter(input => this.previousInputs[input] !== this[input])
+                .forEach(input => this.previousInputs[input] = this[input]);
+        }
+    }
+    setFormValues(formValues, resetFirst = true) {
+        if (formValues) {
+            const newFormValues = this.objectWrap ? formValues['1'] : formValues;
+            if (!this.jsf.formGroup) {
+                this.jsf.formValues = formValues;
+                this.activateForm();
+            }
+            else if (resetFirst) { //changed to avoid reset events
+                this.jsf.formGroup.reset({}, { emitEvent: false });
+            }
+            if (this.jsf.formGroup) { //changed to avoid reset events
+                this.jsf.formGroup.patchValue(newFormValues, { emitEvent: false });
+            }
+            if (this.onChange) {
+                this.onChange(newFormValues);
+            }
+            if (this.onTouched) {
+                this.onTouched(newFormValues);
+            }
+        }
+        else {
+            this.jsf.formGroup.reset();
+        }
+    }
+    submitForm() {
+        const validData = this.jsf.validData;
+        this.onSubmit.emit(this.objectWrap ? validData['1'] : validData);
+    }
+    /**
+     * 'initializeForm' function
+     *
+     * - Update 'schema', 'layout', and 'formValues', from inputs.
+     *
+     * - Create 'schemaRefLibrary' and 'schemaRecursiveRefMap'
+     *   to resolve schema $ref links, including recursive $ref links.
+     *
+     * - Create 'dataRecursiveRefMap' to resolve recursive links in data
+     *   and corectly set output formats for recursively nested values.
+     *
+     * - Create 'layoutRefLibrary' and 'templateRefLibrary' to store
+     *   new layout nodes and formGroup elements to use when dynamically
+     *   adding form components to arrays and recursive $ref points.
+     *
+     * - Create 'dataMap' to map the data to the schema and template.
+     *
+     * - Create the master 'formGroupTemplate' then from it 'formGroup'
+     *   the Angular formGroup used to control the reactive form.
+     */
+    initializeForm(initialData) {
+        if (this.schema || this.layout || this.data || this.form || this.model ||
+            this.JSONSchema || this.UISchema || this.formData || this.ngModel ||
+            this.jsf.data) {
+            // Reset all form values to defaults
+            this.jsf.resetAllValues();
+            this.initializeOptions(); // Update options
+            this.initializeSchema(); // Update schema, schemaRefLibrary,
+            // schemaRecursiveRefMap, & dataRecursiveRefMap
+            this.initializeLayout(); // Update layout, layoutRefLibrary,
+            this.initializeData(); // Update formValues
+            if (initialData) {
+                this.jsf.formValues = initialData;
+            }
+            this.activateForm(); // Update dataMap, templateRefLibrary,
+            // formGroupTemplate, formGroup
+            // Uncomment individual lines to output debugging information to console:
+            // (These always work.)
+            // console.log('loading form...');
+            // console.log('schema', this.jsf.schema);
+            // console.log('layout', this.jsf.layout);
+            // console.log('options', this.options);
+            // console.log('formValues', this.jsf.formValues);
+            // console.log('formGroupTemplate', this.jsf.formGroupTemplate);
+            // console.log('formGroup', this.jsf.formGroup);
+            // console.log('formGroup.value', this.jsf.formGroup.value);
+            // console.log('schemaRefLibrary', this.jsf.schemaRefLibrary);
+            // console.log('layoutRefLibrary', this.jsf.layoutRefLibrary);
+            // console.log('templateRefLibrary', this.jsf.templateRefLibrary);
+            // console.log('dataMap', this.jsf.dataMap);
+            // console.log('arrayMap', this.jsf.arrayMap);
+            // console.log('schemaRecursiveRefMap', this.jsf.schemaRecursiveRefMap);
+            // console.log('dataRecursiveRefMap', this.jsf.dataRecursiveRefMap);
+            // Uncomment individual lines to output debugging information to browser:
+            // (These only work if the 'debug' option has also been set to 'true'.)
+            if (this.debug || this.jsf.formOptions.debug) {
+                const vars = [];
+                // vars.push(this.jsf.schema);
+                // vars.push(this.jsf.layout);
+                // vars.push(this.options);
+                // vars.push(this.jsf.formValues);
+                // vars.push(this.jsf.formGroup.value);
+                // vars.push(this.jsf.formGroupTemplate);
+                // vars.push(this.jsf.formGroup);
+                // vars.push(this.jsf.schemaRefLibrary);
+                // vars.push(this.jsf.layoutRefLibrary);
+                // vars.push(this.jsf.templateRefLibrary);
+                // vars.push(this.jsf.dataMap);
+                // vars.push(this.jsf.arrayMap);
+                // vars.push(this.jsf.schemaRecursiveRefMap);
+                // vars.push(this.jsf.dataRecursiveRefMap);
+                this.debugOutput = vars.map(v => JSON.stringify(v, null, 2)).join('\n');
+            }
+            this.formInitialized = true;
+        }
+    }
+    /**
+     * 'initializeOptions' function
+     *
+     * Initialize 'options' (global form options) and set framework
+     * Combine available inputs:
+     * 1. options - recommended
+     * 2. form.options - Single input style
+     */
+    initializeOptions() {
+        if (this.language && this.language !== this.jsf.language) {
+            this.jsf.setLanguage(this.language);
+        }
+        this.jsf.setOptions({ debug: !!this.debug });
+        let loadExternalAssets = this.loadExternalAssets || false;
+        let framework = this.framework || 'default';
+        if (isObject(this.options)) {
+            this.jsf.setOptions(this.options);
+            loadExternalAssets = this.options.loadExternalAssets || loadExternalAssets;
+            framework = this.options.framework || framework;
+        }
+        if (isObject(this.form) && isObject(this.form.options)) {
+            this.jsf.setOptions(this.form.options);
+            loadExternalAssets = this.form.options.loadExternalAssets || loadExternalAssets;
+            framework = this.form.options.framework || framework;
+        }
+        if (isObject(this.widgets)) {
+            this.jsf.setOptions({ widgets: this.widgets });
+        }
+        this.frameworkLibrary.setLoadExternalAssets(loadExternalAssets);
+        this.frameworkLibrary.setFramework(framework);
+        this.jsf.framework = this.frameworkLibrary.getFramework();
+        if (isObject(this.jsf.formOptions.widgets)) {
+            for (const widget of Object.keys(this.jsf.formOptions.widgets)) {
+                this.widgetLibrary.registerWidget(widget, this.jsf.formOptions.widgets[widget]);
+            }
+        }
+        if (isObject(this.form) && isObject(this.form.tpldata)) {
+            this.jsf.setTpldata(this.form.tpldata);
+        }
+        if (this.theme) {
+            this.frameworkLibrary.requestThemeChange(this.theme);
+        }
+    }
+    /**
+     * 'initializeSchema' function
+     *
+     * Initialize 'schema'
+     * Use first available input:
+     * 1. schema - recommended / Angular Schema Form style
+     * 2. form.schema - Single input / JSON Form style
+     * 3. JSONSchema - React JSON Schema Form style
+     * 4. form.JSONSchema - For testing single input React JSON Schema Forms
+     * 5. form - For testing single schema-only inputs
+     *
+     * ... if no schema input found, the 'activateForm' function, below,
+     *     will make two additional attempts to build a schema
+     * 6. If layout input - build schema from layout
+     * 7. If data input - build schema from data
+     */
+    initializeSchema() {
+        // TODO: update to allow non-object schemas
+        if (isObject(this.schema)) {
+            this.jsf.AngularSchemaFormCompatibility = true;
+            this.jsf.schema = cloneDeep(this.schema);
+        }
+        else if (hasOwn(this.form, 'schema') && isObject(this.form.schema)) {
+            this.jsf.schema = cloneDeep(this.form.schema);
+        }
+        else if (isObject(this.JSONSchema)) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            this.jsf.schema = cloneDeep(this.JSONSchema);
+        }
+        else if (hasOwn(this.form, 'JSONSchema') && isObject(this.form.JSONSchema)) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            this.jsf.schema = cloneDeep(this.form.JSONSchema);
+        }
+        else if (hasOwn(this.form, 'properties') && isObject(this.form.properties)) {
+            this.jsf.schema = cloneDeep(this.form);
+        }
+        else if (isObject(this.form)) {
+            // TODO: Handle other types of form input
+        }
+        if (!isEmpty(this.jsf.schema)) {
+            // If other types also allowed, render schema as an object
+            if (inArray('object', this.jsf.schema.type)) {
+                this.jsf.schema.type = 'object';
+            }
+            // Wrap non-object schemas in object.
+            if (hasOwn(this.jsf.schema, 'type') && this.jsf.schema.type !== 'object') {
+                this.jsf.schema = {
+                    'type': 'object',
+                    'properties': { 1: this.jsf.schema }
+                };
+                this.objectWrap = true;
+            }
+            else if (!hasOwn(this.jsf.schema, 'type')) {
+                // Add type = 'object' if missing
+                if (isObject(this.jsf.schema.properties) ||
+                    isObject(this.jsf.schema.patternProperties) ||
+                    isObject(this.jsf.schema.additionalProperties)) {
+                    this.jsf.schema.type = 'object';
+                    // Fix JSON schema shorthand (JSON Form style)
+                }
+                else {
+                    this.jsf.JsonFormCompatibility = true;
+                    this.jsf.schema = {
+                        'type': 'object',
+                        'properties': this.jsf.schema
+                    };
+                }
+            }
+            // If needed, update JSON Schema to draft 6 format, including
+            // draft 3 (JSON Form style) and draft 4 (Angular Schema Form style)
+            this.jsf.schema = convertSchemaToDraft6(this.jsf.schema);
+            // Initialize ajv and compile schema
+            this.jsf.compileAjvSchema();
+            // Create schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, & arrayMap
+            this.jsf.schema = resolveSchemaReferences(this.jsf.schema, this.jsf.schemaRefLibrary, this.jsf.schemaRecursiveRefMap, this.jsf.dataRecursiveRefMap, this.jsf.arrayMap);
+            if (hasOwn(this.jsf.schemaRefLibrary, '')) {
+                this.jsf.hasRootReference = true;
+            }
+            // TODO: (?) Resolve external $ref links
+            // // Create schemaRefLibrary & schemaRecursiveRefMap
+            // this.parser.bundle(this.schema)
+            //   .then(schema => this.schema = resolveSchemaReferences(
+            //     schema, this.jsf.schemaRefLibrary,
+            //     this.jsf.schemaRecursiveRefMap, this.jsf.dataRecursiveRefMap
+            //   ));
+        }
+    }
+    /**
+     * 'initializeData' function
+     *
+     * Initialize 'formValues'
+     * defulat or previously submitted values used to populate form
+     * Use first available input:
+     * 1. data - recommended
+     * 2. model - Angular Schema Form style
+     * 3. form.value - JSON Form style
+     * 4. form.data - Single input style
+     * 5. formData - React JSON Schema Form style
+     * 6. form.formData - For easier testing of React JSON Schema Forms
+     * 7. (none) no data - initialize data from schema and layout defaults only
+     */
+    initializeData() {
+        if (hasValue(this.data)) {
+            this.jsf.formValues = cloneDeep(this.data);
+            this.formValuesInput = 'data';
+        }
+        else if (hasValue(this.model)) {
+            this.jsf.AngularSchemaFormCompatibility = true;
+            this.jsf.formValues = cloneDeep(this.model);
+            this.formValuesInput = 'model';
+        }
+        else if (hasValue(this.ngModel)) {
+            this.jsf.AngularSchemaFormCompatibility = true;
+            this.jsf.formValues = cloneDeep(this.ngModel);
+            this.formValuesInput = 'ngModel';
+        }
+        else if (isObject(this.form) && hasValue(this.form.value)) {
+            this.jsf.JsonFormCompatibility = true;
+            this.jsf.formValues = cloneDeep(this.form.value);
+            this.formValuesInput = 'form.value';
+        }
+        else if (isObject(this.form) && hasValue(this.form.data)) {
+            this.jsf.formValues = cloneDeep(this.form.data);
+            this.formValuesInput = 'form.data';
+        }
+        else if (hasValue(this.formData)) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            this.formValuesInput = 'formData';
+        }
+        else if (hasOwn(this.form, 'formData') && hasValue(this.form.formData)) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            this.jsf.formValues = cloneDeep(this.form.formData);
+            this.formValuesInput = 'form.formData';
+        }
+        else {
+            this.formValuesInput = "data"; //null;
+        }
+    }
+    /**
+     * 'initializeLayout' function
+     *
+     * Initialize 'layout'
+     * Use first available array input:
+     * 1. layout - recommended
+     * 2. form - Angular Schema Form style
+     * 3. form.form - JSON Form style
+     * 4. form.layout - Single input style
+     * 5. (none) no layout - set default layout instead
+     *    (full layout will be built later from the schema)
+     *
+     * Also, if alternate layout formats are available,
+     * import from 'UISchema' or 'customFormItems'
+     * used for React JSON Schema Form and JSON Form API compatibility
+     * Use first available input:
+     * 1. UISchema - React JSON Schema Form style
+     * 2. form.UISchema - For testing single input React JSON Schema Forms
+     * 2. form.customFormItems - JSON Form style
+     * 3. (none) no input - don't import
+     */
+    initializeLayout() {
+        // Rename JSON Form-style 'options' lists to
+        // Angular Schema Form-style 'titleMap' lists.
+        const fixJsonFormOptions = (layout) => {
+            if (isObject(layout) || isArray(layout)) {
+                forEach(layout, (value, key) => {
+                    if (hasOwn(value, 'options') && isObject(value.options)) {
+                        value.titleMap = value.options;
+                        delete value.options;
+                    }
+                }, 'top-down');
+            }
+            return layout;
+        };
+        // Check for layout inputs and, if found, initialize form layout
+        if (isArray(this.layout)) {
+            this.jsf.layout = cloneDeep(this.layout);
+        }
+        else if (isArray(this.form)) {
+            this.jsf.AngularSchemaFormCompatibility = true;
+            this.jsf.layout = cloneDeep(this.form);
+        }
+        else if (this.form && isArray(this.form.form)) {
+            this.jsf.JsonFormCompatibility = true;
+            this.jsf.layout = fixJsonFormOptions(cloneDeep(this.form.form));
+        }
+        else if (this.form && isArray(this.form.layout)) {
+            this.jsf.layout = cloneDeep(this.form.layout);
+        }
+        else {
+            this.jsf.layout = ['*'];
+        }
+        // Check for alternate layout inputs
+        let alternateLayout = null;
+        if (isObject(this.UISchema)) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            alternateLayout = cloneDeep(this.UISchema);
+        }
+        else if (hasOwn(this.form, 'UISchema')) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            alternateLayout = cloneDeep(this.form.UISchema);
+        }
+        else if (hasOwn(this.form, 'uiSchema')) {
+            this.jsf.ReactJsonSchemaFormCompatibility = true;
+            alternateLayout = cloneDeep(this.form.uiSchema);
+        }
+        else if (hasOwn(this.form, 'customFormItems')) {
+            this.jsf.JsonFormCompatibility = true;
+            alternateLayout = fixJsonFormOptions(cloneDeep(this.form.customFormItems));
+        }
+        // if alternate layout found, copy alternate layout options into schema
+        if (alternateLayout) {
+            JsonPointer.forEachDeep(alternateLayout, (value, pointer) => {
+                const schemaPointer = pointer
+                    .replace(/\//g, '/properties/')
+                    .replace(/\/properties\/items\/properties\//g, '/items/properties/')
+                    .replace(/\/properties\/titleMap\/properties\//g, '/titleMap/properties/');
+                if (hasValue(value) && hasValue(pointer)) {
+                    let key = JsonPointer.toKey(pointer);
+                    const groupPointer = (JsonPointer.parse(schemaPointer) || []).slice(0, -2);
+                    let itemPointer;
+                    // If 'ui:order' object found, copy into object schema root
+                    if (key.toLowerCase() === 'ui:order') {
+                        itemPointer = [...groupPointer, 'ui:order'];
+                        // Copy other alternate layout options to schema 'x-schema-form',
+                        // (like Angular Schema Form options) and remove any 'ui:' prefixes
+                    }
+                    else {
+                        if (key.slice(0, 3).toLowerCase() === 'ui:') {
+                            key = key.slice(3);
+                        }
+                        itemPointer = [...groupPointer, 'x-schema-form', key];
+                    }
+                    if (JsonPointer.has(this.jsf.schema, groupPointer) &&
+                        !JsonPointer.has(this.jsf.schema, itemPointer)) {
+                        JsonPointer.set(this.jsf.schema, itemPointer, value);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * 'activateForm' function
+     *
+     * ...continued from 'initializeSchema' function, above
+     * If 'schema' has not been initialized (i.e. no schema input found)
+     * 6. If layout input - build schema from layout input
+     * 7. If data input - build schema from data input
+     *
+     * Create final layout,
+     * build the FormGroup template and the Angular FormGroup,
+     * subscribe to changes,
+     * and activate the form.
+     */
+    activateForm() {
+        this.unsubscribeOnActivateForm$.next();
+        // If 'schema' not initialized
+        if (isEmpty(this.jsf.schema)) {
+            // TODO: If full layout input (with no '*'), build schema from layout
+            // if (!this.jsf.layout.includes('*')) {
+            //   this.jsf.buildSchemaFromLayout();
+            // } else
+            // If data input, build schema from data
+            if (!isEmpty(this.jsf.formValues)) {
+                this.jsf.buildSchemaFromData();
+            }
+        }
+        if (!isEmpty(this.jsf.schema)) {
+            // If not already initialized, initialize ajv and compile schema
+            this.jsf.compileAjvSchema();
+            // Update all layout elements, add values, widgets, and validators,
+            // replace any '*' with a layout built from all schema elements,
+            // and update the FormGroup template with any new validators
+            this.jsf.buildLayout(this.widgetLibrary);
+            // Build the Angular FormGroup template from the schema
+            this.jsf.buildFormGroupTemplate(this.jsf.formValues);
+            // Build the real Angular FormGroup from the FormGroup template
+            this.jsf.buildFormGroup();
+        }
+        if (this.jsf.formGroup) {
+            // Reset initial form values
+            if (!isEmpty(this.jsf.formValues) &&
+                this.jsf.formOptions.setSchemaDefaults !== true &&
+                this.jsf.formOptions.setLayoutDefaults !== true) {
+                this.setFormValues(this.jsf.formValues);
+            }
+            // TODO: Figure out how to display calculated values without changing object data
+            // See http://ulion.github.io/jsonform/playground/?example=templating-values
+            // Calculate references to other fields
+            // if (!isEmpty(this.jsf.formGroup.value)) {
+            //   forEach(this.jsf.formGroup.value, (value, key, object, rootObject) => {
+            //     if (typeof value === 'string') {
+            //       object[key] = this.jsf.parseText(value, value, rootObject, key);
+            //     }
+            //   }, 'top-down');
+            // }
+            // Subscribe to form changes to output live data, validation, and errors
+            this.dataChangesSubs = this.jsf.dataChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(data => {
+                this.onChanges.emit(this.objectWrap ? data['1'] : data);
+                if (this.formValuesInput && this.formValuesInput.indexOf('.') === -1) {
+                    this[`${this.formValuesInput}Change`].emit(this.objectWrap ? data['1'] : data);
+                }
+            });
+            // Trigger change detection on statusChanges to show updated errors
+            this.statusChangesSubs = this.jsf.formGroup.statusChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(() => this.changeDetector.markForCheck());
+            this.isValidChangesSubs = this.jsf.isValidChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(isValid => this.isValid.emit(isValid));
+            this.validationErrorChangesSubs = this.jsf.validationErrorChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(err => this.validationErrors.emit(err));
+            // Output final schema, final layout, and initial data
+            this.formSchema.emit(this.jsf.schema);
+            this.formLayout.emit(this.jsf.layout);
+            this.onChanges.emit(this.objectWrap ? this.jsf.data['1'] : this.jsf.data);
+            // If validateOnRender, output initial validation and any errors
+            const validateOnRender = JsonPointer.get(this.jsf, '/formOptions/validateOnRender');
+            if (validateOnRender) { // validateOnRender === 'auto' || true
+                const touchAll = (control) => {
+                    if (validateOnRender === true || hasValue(control.value)) {
+                        control.markAsTouched();
+                    }
+                    Object.keys(control.controls || {})
+                        .forEach(key => touchAll(control.controls[key]));
+                };
+                touchAll(this.jsf.formGroup);
+                this.isValid.emit(this.jsf.isValid);
+                this.validationErrors.emit(this.jsf.ajvErrors);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonSchemaFormComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.FrameworkLibraryService }, { token: i2.WidgetLibraryService }, { token: i3.JsonSchemaFormService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: JsonSchemaFormComponent, selector: "json-schema-form", inputs: { schema: "schema", layout: "layout", data: "data", options: "options", framework: "framework", widgets: "widgets", form: "form", model: "model", JSONSchema: "JSONSchema", UISchema: "UISchema", formData: "formData", ngModel: "ngModel", language: "language", loadExternalAssets: "loadExternalAssets", debug: "debug", theme: "theme", value: "value" }, outputs: { onChanges: "onChanges", onSubmit: "onSubmit", isValid: "isValid", validationErrors: "validationErrors", formSchema: "formSchema", formLayout: "formLayout", dataChange: "dataChange", modelChange: "modelChange", formDataChange: "formDataChange", ngModelChange: "ngModelChange" }, providers: [JsonSchemaFormService, JSON_SCHEMA_FORM_VALUE_ACCESSOR], usesOnChanges: true, ngImport: i0, template: "<form [autocomplete]=\"jsf?.formOptions?.autocomplete ? 'on' : 'off'\" class=\"json-schema-form\" (ngSubmit)=\"submitForm()\">\r\n  <root-widget [layout]=\"jsf?.layout\"></root-widget>\r\n</form>\r\n<div *ngIf=\"debug || jsf?.formOptions?.debug\">\r\n  Debug output:\r\n  <pre>{{debugOutput}}</pre>\r\n</div>", dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i6.RootComponent, selector: "root-widget", inputs: ["dataIndex", "layoutIndex", "layout", "isOrderable", "isFlexItem"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonSchemaFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'json-schema-form', changeDetection: ChangeDetectionStrategy.OnPush, providers: [JsonSchemaFormService, JSON_SCHEMA_FORM_VALUE_ACCESSOR], template: "<form [autocomplete]=\"jsf?.formOptions?.autocomplete ? 'on' : 'off'\" class=\"json-schema-form\" (ngSubmit)=\"submitForm()\">\r\n  <root-widget [layout]=\"jsf?.layout\"></root-widget>\r\n</form>\r\n<div *ngIf=\"debug || jsf?.formOptions?.debug\">\r\n  Debug output:\r\n  <pre>{{debugOutput}}</pre>\r\n</div>" }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.FrameworkLibraryService }, { type: i2.WidgetLibraryService }, { type: i3.JsonSchemaFormService }], propDecorators: { schema: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], framework: [{
+                type: Input
+            }], widgets: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], JSONSchema: [{
+                type: Input
+            }], UISchema: [{
+                type: Input
+            }], formData: [{
+                type: Input
+            }], ngModel: [{
+                type: Input
+            }], language: [{
+                type: Input
+            }], loadExternalAssets: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], onChanges: [{
+                type: Output
+            }], onSubmit: [{
+                type: Output
+            }], isValid: [{
+                type: Output
+            }], validationErrors: [{
+                type: Output
+            }], formSchema: [{
+                type: Output
+            }], formLayout: [{
+                type: Output
+            }], dataChange: [{
+                type: Output
+            }], modelChange: [{
+                type: Output
+            }], formDataChange: [{
+                type: Output
+            }], ngModelChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema-form.component.js","sourceRoot":"","sources":["../../../../../projects/ng-formworks-core/src/lib/json-schema-form.component.ts","../../../../../projects/ng-formworks-core/src/lib/json-schema-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import cloneDeep from 'lodash/cloneDeep';\r\nimport isEqual from 'lodash/isEqual';\r\n\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  forwardRef,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  SimpleChanges,\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { FrameworkLibraryService } from './framework-library/framework-library.service';\r\nimport { JsonSchemaFormService } from './json-schema-form.service';\r\nimport { convertSchemaToDraft6 } from './shared/convert-schema-to-draft6.function';\r\nimport { resolveSchemaReferences } from './shared/json-schema.functions';\r\nimport { JsonPointer } from './shared/jsonpointer.functions';\r\nimport { forEach, hasOwn } from './shared/utility.functions';\r\nimport {\r\n  hasValue,\r\n  inArray,\r\n  isArray,\r\n  isEmpty,\r\n  isObject\r\n} from './shared/validator.functions';\r\nimport { WidgetLibraryService } from './widget-library/widget-library.service';\r\n\r\nexport const JSON_SCHEMA_FORM_VALUE_ACCESSOR: any = {\r\n  provide: NG_VALUE_ACCESSOR,\r\n  useExisting: forwardRef(() => JsonSchemaFormComponent),\r\n  multi: true,\r\n};\r\n\r\n/**\r\n * @module 'JsonSchemaFormComponent' - Angular JSON Schema Form\r\n *\r\n * Root module of the Angular JSON Schema Form client-side library,\r\n * an Angular library which generates an HTML form from a JSON schema\r\n * structured data model and/or a JSON Schema Form layout description.\r\n *\r\n * This library also validates input data by the user, using both validators on\r\n * individual controls to provide real-time feedback while the user is filling\r\n * out the form, and then validating the entire input against the schema when\r\n * the form is submitted to make sure the returned JSON data object is valid.\r\n *\r\n * This library is similar to, and mostly API compatible with:\r\n *\r\n * - JSON Schema Form's Angular Schema Form library for AngularJs\r\n *   http://schemaform.io\r\n *   http://schemaform.io/examples/bootstrap-example.html (examples)\r\n *\r\n * - Mozilla's react-jsonschema-form library for React\r\n *   https://github.com/mozilla-services/react-jsonschema-form\r\n *   https://mozilla-services.github.io/react-jsonschema-form (examples)\r\n *\r\n * - Joshfire's JSON Form library for jQuery\r\n *   https://github.com/joshfire/jsonform\r\n *   http://ulion.github.io/jsonform/playground (examples)\r\n *\r\n * This library depends on:\r\n *  - Angular (obviously)                  https://angular.io\r\n *  - lodash, JavaScript utility library   https://github.com/lodash/lodash\r\n *  - ajv, Another JSON Schema validator   https://github.com/epoberezkin/ajv\r\n *\r\n * In addition, the Example Playground also depends on:\r\n *  - brace, Browserified Ace editor       http://thlorenz.github.io/brace\r\n */\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: 'json-schema-form',\r\n  templateUrl: './json-schema-form.component.html',\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  // Adding 'JsonSchemaFormService' here, instead of in the module,\r\n  // creates a separate instance of the service for each component\r\n  providers:  [ JsonSchemaFormService, JSON_SCHEMA_FORM_VALUE_ACCESSOR ],\r\n})\r\nexport class JsonSchemaFormComponent implements ControlValueAccessor, OnChanges, OnInit,OnDestroy {\r\n  // TODO: quickfix to avoid subscribing twice to the same emitters\r\n  private unsubscribeOnActivateForm$ = new Subject<void>();\r\n\r\n  debugOutput: any; // Debug information, if requested\r\n  formValueSubscription: any = null;\r\n  formInitialized = false;\r\n  objectWrap = false; // Is non-object input schema wrapped in an object?\r\n\r\n  formValuesInput: string; // Name of the input providing the form data\r\n  previousInputs: { // Previous input values, to detect which input triggers onChanges\r\n    schema: any, layout: any[], data: any, options: any, framework: any | string,\r\n    widgets: any, form: any, model: any, JSONSchema: any, UISchema: any,\r\n    formData: any, loadExternalAssets: boolean, debug: boolean,\r\n  } = {\r\n      schema: null, layout: null, data: null, options: null, framework: null,\r\n      widgets: null, form: null, model: null, JSONSchema: null, UISchema: null,\r\n      formData: null, loadExternalAssets: null, debug: null,\r\n    };\r\n\r\n  // Recommended inputs\r\n  @Input() schema: any; // The JSON Schema\r\n  @Input() layout: any[]; // The form layout\r\n  @Input() data: any; // The form data\r\n  @Input() options: any; // The global form options\r\n  @Input() framework: any | string; // The framework to load\r\n  @Input() widgets: any; // Any custom widgets to load\r\n\r\n  // Alternate combined single input\r\n  @Input() form: any; // For testing, and JSON Schema Form API compatibility\r\n\r\n  // Angular Schema Form API compatibility input\r\n  @Input() model: any; // Alternate input for form data\r\n\r\n  // React JSON Schema Form API compatibility inputs\r\n  @Input() JSONSchema: any; // Alternate input for JSON Schema\r\n  @Input() UISchema: any; // UI schema - alternate form layout format\r\n  @Input() formData: any; // Alternate input for form data\r\n\r\n  @Input() ngModel: any; // Alternate input for Angular forms\r\n\r\n  @Input() language: string; // Language\r\n\r\n  // Development inputs, for testing and debugging\r\n  @Input() loadExternalAssets: boolean; // Load external framework assets?\r\n  @Input() debug: boolean; // Show debug information?\r\n\r\n  @Input() theme: string; // Theme\r\n\r\n  @Input()\r\n  get value(): any {\r\n    return this.objectWrap ? this.jsf.data['1'] : this.jsf.data;\r\n  }\r\n  set value(value: any) {\r\n    this.setFormValues(value, false);\r\n  }\r\n\r\n  // Outputs\r\n  @Output() onChanges = new EventEmitter<any>(); // Live unvalidated internal form data\r\n  @Output() onSubmit = new EventEmitter<any>(); // Complete validated form data\r\n  @Output() isValid = new EventEmitter<boolean>(); // Is current data valid?\r\n  @Output() validationErrors = new EventEmitter<any>(); // Validation errors (if any)\r\n  @Output() formSchema = new EventEmitter<any>(); // Final schema used to create form\r\n  @Output() formLayout = new EventEmitter<any>(); // Final layout used to create form\r\n\r\n  // Outputs for possible 2-way data binding\r\n  // Only the one input providing the initial form data will be bound.\r\n  // If there is no inital data, input '{}' to activate 2-way data binding.\r\n  // There is no 2-way binding if inital data is combined inside the 'form' input.\r\n  @Output() dataChange = new EventEmitter<any>();\r\n  @Output() modelChange = new EventEmitter<any>();\r\n  @Output() formDataChange = new EventEmitter<any>();\r\n  @Output() ngModelChange = new EventEmitter<any>();\r\n\r\n  onChange: Function;\r\n  onTouched: Function;\r\n\r\n  //TODO-review,maybe use takeUntilDestroyed rxjs op\r\n  dataChangesSubs:Subscription;\r\n  statusChangesSubs:Subscription;\r\n  isValidChangesSubs:Subscription;\r\n  validationErrorChangesSubs:Subscription;\r\n\r\n  constructor(\r\n    private changeDetector: ChangeDetectorRef,\r\n    private frameworkLibrary: FrameworkLibraryService,\r\n    private widgetLibrary: WidgetLibraryService,\r\n    public jsf: JsonSchemaFormService,\r\n  ) { }\r\n  ngOnDestroy(): void {\r\n    this.dataChangesSubs?.unsubscribe();\r\n    this.statusChangesSubs?.unsubscribe();\r\n    this.isValidChangesSubs?.unsubscribe();\r\n    this.validationErrorChangesSubs?.unsubscribe();\r\n    this.dataChangesSubs=null;\r\n    this.statusChangesSubs=null;\r\n    this.isValidChangesSubs=null;\r\n    this.validationErrorChangesSubs=null;\r\n  }\r\n\r\n  private resetScriptsAndStyleSheets() {\r\n    document.querySelectorAll('.ajsf').forEach(element => element.remove());\r\n  }\r\n  private loadScripts(scriptList?:string[]) {\r\n    const scripts = scriptList||this.frameworkLibrary.getFrameworkScripts();\r\n    scripts.map(script => {\r\n      const scriptTag: HTMLScriptElement = document.createElement('script');\r\n      scriptTag.src = script;\r\n      scriptTag.type = 'text/javascript';\r\n      scriptTag.async = true;\r\n      scriptTag.setAttribute('class', 'ajsf');\r\n      document.getElementsByTagName('head')[0].appendChild(scriptTag);\r\n    });\r\n  }\r\n  private loadStyleSheets(styleList?:string[]) {\r\n    const stylesheets = styleList||this.frameworkLibrary.getFrameworkStylesheets();\r\n    stylesheets.map(stylesheet => {\r\n      const linkTag: HTMLLinkElement = document.createElement('link');\r\n      linkTag.rel = 'stylesheet';\r\n      linkTag.href = stylesheet;\r\n      linkTag.setAttribute('class', 'ajsf');\r\n      document.getElementsByTagName('head')[0].appendChild(linkTag);\r\n    });\r\n  }\r\n  private loadAssets() {\r\n    this.frameworkLibrary.getFrameworkAssetConfig().then(assetCfg=>{\r\n      this.resetScriptsAndStyleSheets();\r\n      this.loadScripts(assetCfg.scripts);\r\n      this.loadStyleSheets(assetCfg.stylesheets);\r\n    }).catch(err=>{\r\n      console.log(err);\r\n      this.resetScriptsAndStyleSheets();\r\n      this.loadScripts();\r\n      this.loadStyleSheets();\r\n    })\r\n\r\n  }\r\n  ngOnInit() {\r\n    this.updateForm();\r\n    this.loadAssets();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    this.updateForm();\r\n    // Check if there's changes in Framework then load assets if that's the\r\n    if (changes.framework) {\r\n      if (!changes.framework.isFirstChange() &&\r\n        (changes.framework.previousValue !== changes.framework.currentValue)) {\r\n        this.loadAssets();\r\n      }\r\n    }\r\n  }\r\n\r\n  writeValue(value: any) {\r\n    this.setFormValues(value, false);\r\n    if (!this.formValuesInput) { this.formValuesInput = 'ngModel'; }\r\n  }\r\n\r\n  registerOnChange(fn: Function) {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: Function) {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  //see note\r\n  //https://angular.io/guide/update-to-version-15#v15-bc-06\r\n  setDisabledState(isDisabled: boolean) {\r\n    if (this.jsf.formOptions.formDisabled !== !!isDisabled) {\r\n      this.jsf.formOptions.formDisabled = !!isDisabled;\r\n      this.initializeForm();\r\n    }\r\n  }\r\n\r\n  updateForm() {\r\n      let changedData;\r\n    if (!this.formInitialized || !this.formValuesInput ||\r\n      (this.language && this.language !== this.jsf.language)\r\n      \r\n    ) {\r\n      this.initializeForm();\r\n    } else {\r\n      if (this.language && this.language !== this.jsf.language) {\r\n        this.jsf.setLanguage(this.language);\r\n      }\r\n\r\n      // Get names of changed inputs\r\n      let changedInput = Object.keys(this.previousInputs)\r\n        .filter(input => this.previousInputs[input] !== this[input]);\r\n      let resetFirst = true;\r\n      if (changedInput.length === 1 && changedInput[0] === 'form' &&\r\n        this.formValuesInput.startsWith('form.')\r\n      ) {\r\n        // If only 'form' input changed, get names of changed keys\r\n        changedInput = Object.keys(this.previousInputs.form || {})\r\n          .filter(key => !isEqual(this.previousInputs.form[key], this.form[key]))\r\n          .map(key => `form.${key}`);\r\n        resetFirst = false;\r\n      }\r\n\r\n      // If only input values have changed, update the form values\r\n      if (changedInput.length === 1 && changedInput[0] === this.formValuesInput) {\r\n        if (this.formValuesInput.indexOf('.') === -1) {\r\n          changedData=this[this.formValuesInput];\r\n          this.setFormValues(changedData, resetFirst);\r\n        } else {\r\n          const [input, key] = this.formValuesInput.split('.');\r\n          changedData=this[input][key];\r\n          this.setFormValues(changedData, resetFirst);\r\n        }\r\n\r\n        // If anything else has changed, re-render the entire form\r\n      } else if (changedInput.length) {\r\n        this.initializeForm(changedData);\r\n        if (this.onChange) { this.onChange(this.jsf.formValues); }\r\n        if (this.onTouched) { this.onTouched(this.jsf.formValues); }\r\n      }\r\n      \r\n      //set framework theme\r\n      if (this.theme && this.theme !== this.frameworkLibrary.getActiveTheme()?.name) {\r\n        this.frameworkLibrary.requestThemeChange(this.theme);\r\n      }\r\n\r\n      // Update previous inputs\r\n      Object.keys(this.previousInputs)\r\n        .filter(input => this.previousInputs[input] !== this[input])\r\n        .forEach(input => this.previousInputs[input] = this[input]);\r\n    }\r\n  }\r\n\r\n  setFormValues(formValues: any, resetFirst = true) {\r\n    if (formValues) {\r\n      const newFormValues = this.objectWrap ? formValues['1'] : formValues;\r\n      if (!this.jsf.formGroup) {\r\n        this.jsf.formValues = formValues;\r\n        this.activateForm();\r\n      } else if (resetFirst) {//changed to avoid reset events\r\n        this.jsf.formGroup.reset({},{emitEvent:false});\r\n      }\r\n      if (this.jsf.formGroup) {//changed to avoid reset events\r\n        this.jsf.formGroup.patchValue(newFormValues,{emitEvent:false});\r\n      }\r\n      if (this.onChange) { this.onChange(newFormValues); }\r\n      if (this.onTouched) { this.onTouched(newFormValues); }\r\n    } else {\r\n      this.jsf.formGroup.reset();\r\n    }\r\n  }\r\n\r\n  submitForm() {\r\n    const validData = this.jsf.validData;\r\n    this.onSubmit.emit(this.objectWrap ? validData['1'] : validData);\r\n  }\r\n\r\n  /**\r\n   * 'initializeForm' function\r\n   *\r\n   * - Update 'schema', 'layout', and 'formValues', from inputs.\r\n   *\r\n   * - Create 'schemaRefLibrary' and 'schemaRecursiveRefMap'\r\n   *   to resolve schema $ref links, including recursive $ref links.\r\n   *\r\n   * - Create 'dataRecursiveRefMap' to resolve recursive links in data\r\n   *   and corectly set output formats for recursively nested values.\r\n   *\r\n   * - Create 'layoutRefLibrary' and 'templateRefLibrary' to store\r\n   *   new layout nodes and formGroup elements to use when dynamically\r\n   *   adding form components to arrays and recursive $ref points.\r\n   *\r\n   * - Create 'dataMap' to map the data to the schema and template.\r\n   *\r\n   * - Create the master 'formGroupTemplate' then from it 'formGroup'\r\n   *   the Angular formGroup used to control the reactive form.\r\n   */\r\n  initializeForm(initialData?:any) {\r\n    if (\r\n      this.schema || this.layout || this.data || this.form || this.model ||\r\n      this.JSONSchema || this.UISchema || this.formData || this.ngModel ||\r\n      this.jsf.data\r\n    ) {\r\n      // Reset all form values to defaults\r\n      this.jsf.resetAllValues();\r\n      this.initializeOptions();   // Update options\r\n      this.initializeSchema();    // Update schema, schemaRefLibrary,\r\n      // schemaRecursiveRefMap, & dataRecursiveRefMap\r\n      this.initializeLayout();    // Update layout, layoutRefLibrary,\r\n      this.initializeData();      // Update formValues\r\n      if(initialData){\r\n        this.jsf.formValues=initialData;\r\n      }\r\n      this.activateForm();        // Update dataMap, templateRefLibrary,\r\n      // formGroupTemplate, formGroup\r\n\r\n      // Uncomment individual lines to output debugging information to console:\r\n      // (These always work.)\r\n      // console.log('loading form...');\r\n      // console.log('schema', this.jsf.schema);\r\n      // console.log('layout', this.jsf.layout);\r\n      // console.log('options', this.options);\r\n      // console.log('formValues', this.jsf.formValues);\r\n      // console.log('formGroupTemplate', this.jsf.formGroupTemplate);\r\n      // console.log('formGroup', this.jsf.formGroup);\r\n      // console.log('formGroup.value', this.jsf.formGroup.value);\r\n      // console.log('schemaRefLibrary', this.jsf.schemaRefLibrary);\r\n      // console.log('layoutRefLibrary', this.jsf.layoutRefLibrary);\r\n      // console.log('templateRefLibrary', this.jsf.templateRefLibrary);\r\n      // console.log('dataMap', this.jsf.dataMap);\r\n      // console.log('arrayMap', this.jsf.arrayMap);\r\n      // console.log('schemaRecursiveRefMap', this.jsf.schemaRecursiveRefMap);\r\n      // console.log('dataRecursiveRefMap', this.jsf.dataRecursiveRefMap);\r\n\r\n      // Uncomment individual lines to output debugging information to browser:\r\n      // (These only work if the 'debug' option has also been set to 'true'.)\r\n      if (this.debug || this.jsf.formOptions.debug) {\r\n        const vars: any[] = [];\r\n        // vars.push(this.jsf.schema);\r\n        // vars.push(this.jsf.layout);\r\n        // vars.push(this.options);\r\n        // vars.push(this.jsf.formValues);\r\n        // vars.push(this.jsf.formGroup.value);\r\n        // vars.push(this.jsf.formGroupTemplate);\r\n        // vars.push(this.jsf.formGroup);\r\n        // vars.push(this.jsf.schemaRefLibrary);\r\n        // vars.push(this.jsf.layoutRefLibrary);\r\n        // vars.push(this.jsf.templateRefLibrary);\r\n        // vars.push(this.jsf.dataMap);\r\n        // vars.push(this.jsf.arrayMap);\r\n        // vars.push(this.jsf.schemaRecursiveRefMap);\r\n        // vars.push(this.jsf.dataRecursiveRefMap);\r\n        this.debugOutput = vars.map(v => JSON.stringify(v, null, 2)).join('\\n');\r\n      }\r\n      this.formInitialized = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'initializeOptions' function\r\n   *\r\n   * Initialize 'options' (global form options) and set framework\r\n   * Combine available inputs:\r\n   * 1. options - recommended\r\n   * 2. form.options - Single input style\r\n   */\r\n  private initializeOptions() {\r\n    if (this.language && this.language !== this.jsf.language) {\r\n      this.jsf.setLanguage(this.language);\r\n    }\r\n    this.jsf.setOptions({ debug: !!this.debug });\r\n    let loadExternalAssets: boolean = this.loadExternalAssets || false;\r\n    let framework: any = this.framework || 'default';\r\n    if (isObject(this.options)) {\r\n      this.jsf.setOptions(this.options);\r\n      loadExternalAssets = this.options.loadExternalAssets || loadExternalAssets;\r\n      framework = this.options.framework || framework;\r\n    }\r\n    if (isObject(this.form) && isObject(this.form.options)) {\r\n      this.jsf.setOptions(this.form.options);\r\n      loadExternalAssets = this.form.options.loadExternalAssets || loadExternalAssets;\r\n      framework = this.form.options.framework || framework;\r\n    }\r\n    if (isObject(this.widgets)) {\r\n      this.jsf.setOptions({ widgets: this.widgets });\r\n    }\r\n    this.frameworkLibrary.setLoadExternalAssets(loadExternalAssets);\r\n    this.frameworkLibrary.setFramework(framework);\r\n    this.jsf.framework = this.frameworkLibrary.getFramework();\r\n    if (isObject(this.jsf.formOptions.widgets)) {\r\n      for (const widget of Object.keys(this.jsf.formOptions.widgets)) {\r\n        this.widgetLibrary.registerWidget(widget, this.jsf.formOptions.widgets[widget]);\r\n      }\r\n    }\r\n    if (isObject(this.form) && isObject(this.form.tpldata)) {\r\n      this.jsf.setTpldata(this.form.tpldata);\r\n    }\r\n    if (this.theme) {\r\n      this.frameworkLibrary.requestThemeChange(this.theme);\r\n    }\r\n  }\r\n\r\n\r\n  /**\r\n   * 'initializeSchema' function\r\n   *\r\n   * Initialize 'schema'\r\n   * Use first available input:\r\n   * 1. schema - recommended / Angular Schema Form style\r\n   * 2. form.schema - Single input / JSON Form style\r\n   * 3. JSONSchema - React JSON Schema Form style\r\n   * 4. form.JSONSchema - For testing single input React JSON Schema Forms\r\n   * 5. form - For testing single schema-only inputs\r\n   *\r\n   * ... if no schema input found, the 'activateForm' function, below,\r\n   *     will make two additional attempts to build a schema\r\n   * 6. If layout input - build schema from layout\r\n   * 7. If data input - build schema from data\r\n   */\r\n  private initializeSchema() {\r\n\r\n    // TODO: update to allow non-object schemas\r\n\r\n    if (isObject(this.schema)) {\r\n      this.jsf.AngularSchemaFormCompatibility = true;\r\n      this.jsf.schema = cloneDeep(this.schema);\r\n    } else if (hasOwn(this.form, 'schema') && isObject(this.form.schema)) {\r\n      this.jsf.schema = cloneDeep(this.form.schema);\r\n    } else if (isObject(this.JSONSchema)) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      this.jsf.schema = cloneDeep(this.JSONSchema);\r\n    } else if (hasOwn(this.form, 'JSONSchema') && isObject(this.form.JSONSchema)) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      this.jsf.schema = cloneDeep(this.form.JSONSchema);\r\n    } else if (hasOwn(this.form, 'properties') && isObject(this.form.properties)) {\r\n      this.jsf.schema = cloneDeep(this.form);\r\n    } else if (isObject(this.form)) {\r\n      // TODO: Handle other types of form input\r\n    }\r\n\r\n    if (!isEmpty(this.jsf.schema)) {\r\n\r\n      // If other types also allowed, render schema as an object\r\n      if (inArray('object', this.jsf.schema.type)) {\r\n        this.jsf.schema.type = 'object';\r\n      }\r\n\r\n      // Wrap non-object schemas in object.\r\n      if (hasOwn(this.jsf.schema, 'type') && this.jsf.schema.type !== 'object') {\r\n        this.jsf.schema = {\r\n          'type': 'object',\r\n          'properties': { 1: this.jsf.schema }\r\n        };\r\n        this.objectWrap = true;\r\n      } else if (!hasOwn(this.jsf.schema, 'type')) {\r\n\r\n        // Add type = 'object' if missing\r\n        if (isObject(this.jsf.schema.properties) ||\r\n          isObject(this.jsf.schema.patternProperties) ||\r\n          isObject(this.jsf.schema.additionalProperties)\r\n        ) {\r\n          this.jsf.schema.type = 'object';\r\n\r\n          // Fix JSON schema shorthand (JSON Form style)\r\n        } else {\r\n          this.jsf.JsonFormCompatibility = true;\r\n          this.jsf.schema = {\r\n            'type': 'object',\r\n            'properties': this.jsf.schema\r\n          };\r\n        }\r\n      }\r\n\r\n      // If needed, update JSON Schema to draft 6 format, including\r\n      // draft 3 (JSON Form style) and draft 4 (Angular Schema Form style)\r\n      this.jsf.schema = convertSchemaToDraft6(this.jsf.schema);\r\n\r\n      // Initialize ajv and compile schema\r\n      this.jsf.compileAjvSchema();\r\n\r\n      // Create schemaRefLibrary, schemaRecursiveRefMap, dataRecursiveRefMap, & arrayMap\r\n      this.jsf.schema = resolveSchemaReferences(\r\n        this.jsf.schema, this.jsf.schemaRefLibrary, this.jsf.schemaRecursiveRefMap,\r\n        this.jsf.dataRecursiveRefMap, this.jsf.arrayMap\r\n      );\r\n      if (hasOwn(this.jsf.schemaRefLibrary, '')) {\r\n        this.jsf.hasRootReference = true;\r\n      }\r\n\r\n      // TODO: (?) Resolve external $ref links\r\n      // // Create schemaRefLibrary & schemaRecursiveRefMap\r\n      // this.parser.bundle(this.schema)\r\n      //   .then(schema => this.schema = resolveSchemaReferences(\r\n      //     schema, this.jsf.schemaRefLibrary,\r\n      //     this.jsf.schemaRecursiveRefMap, this.jsf.dataRecursiveRefMap\r\n      //   ));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'initializeData' function\r\n   *\r\n   * Initialize 'formValues'\r\n   * defulat or previously submitted values used to populate form\r\n   * Use first available input:\r\n   * 1. data - recommended\r\n   * 2. model - Angular Schema Form style\r\n   * 3. form.value - JSON Form style\r\n   * 4. form.data - Single input style\r\n   * 5. formData - React JSON Schema Form style\r\n   * 6. form.formData - For easier testing of React JSON Schema Forms\r\n   * 7. (none) no data - initialize data from schema and layout defaults only\r\n   */\r\n  private initializeData() {\r\n    if (hasValue(this.data)) {\r\n      this.jsf.formValues = cloneDeep(this.data);\r\n      this.formValuesInput = 'data';\r\n    } else if (hasValue(this.model)) {\r\n      this.jsf.AngularSchemaFormCompatibility = true;\r\n      this.jsf.formValues = cloneDeep(this.model);\r\n      this.formValuesInput = 'model';\r\n    } else if (hasValue(this.ngModel)) {\r\n      this.jsf.AngularSchemaFormCompatibility = true;\r\n      this.jsf.formValues = cloneDeep(this.ngModel);\r\n      this.formValuesInput = 'ngModel';\r\n    } else if (isObject(this.form) && hasValue(this.form.value)) {\r\n      this.jsf.JsonFormCompatibility = true;\r\n      this.jsf.formValues = cloneDeep(this.form.value);\r\n      this.formValuesInput = 'form.value';\r\n    } else if (isObject(this.form) && hasValue(this.form.data)) {\r\n      this.jsf.formValues = cloneDeep(this.form.data);\r\n      this.formValuesInput = 'form.data';\r\n    } else if (hasValue(this.formData)) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      this.formValuesInput = 'formData';\r\n    } else if (hasOwn(this.form, 'formData') && hasValue(this.form.formData)) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      this.jsf.formValues = cloneDeep(this.form.formData);\r\n      this.formValuesInput = 'form.formData';\r\n    } else {\r\n      this.formValuesInput = \"data\";//null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'initializeLayout' function\r\n   *\r\n   * Initialize 'layout'\r\n   * Use first available array input:\r\n   * 1. layout - recommended\r\n   * 2. form - Angular Schema Form style\r\n   * 3. form.form - JSON Form style\r\n   * 4. form.layout - Single input style\r\n   * 5. (none) no layout - set default layout instead\r\n   *    (full layout will be built later from the schema)\r\n   *\r\n   * Also, if alternate layout formats are available,\r\n   * import from 'UISchema' or 'customFormItems'\r\n   * used for React JSON Schema Form and JSON Form API compatibility\r\n   * Use first available input:\r\n   * 1. UISchema - React JSON Schema Form style\r\n   * 2. form.UISchema - For testing single input React JSON Schema Forms\r\n   * 2. form.customFormItems - JSON Form style\r\n   * 3. (none) no input - don't import\r\n   */\r\n  private initializeLayout() {\r\n\r\n    // Rename JSON Form-style 'options' lists to\r\n    // Angular Schema Form-style 'titleMap' lists.\r\n    const fixJsonFormOptions = (layout: any): any => {\r\n      if (isObject(layout) || isArray(layout)) {\r\n        forEach(layout, (value, key) => {\r\n          if (hasOwn(value, 'options') && isObject(value.options)) {\r\n            value.titleMap = value.options;\r\n            delete value.options;\r\n          }\r\n        }, 'top-down');\r\n      }\r\n      return layout;\r\n    };\r\n\r\n    // Check for layout inputs and, if found, initialize form layout\r\n    if (isArray(this.layout)) {\r\n      this.jsf.layout = cloneDeep(this.layout);\r\n    } else if (isArray(this.form)) {\r\n      this.jsf.AngularSchemaFormCompatibility = true;\r\n      this.jsf.layout = cloneDeep(this.form);\r\n    } else if (this.form && isArray(this.form.form)) {\r\n      this.jsf.JsonFormCompatibility = true;\r\n      this.jsf.layout = fixJsonFormOptions(cloneDeep(this.form.form));\r\n    } else if (this.form && isArray(this.form.layout)) {\r\n      this.jsf.layout = cloneDeep(this.form.layout);\r\n    } else {\r\n      this.jsf.layout = ['*'];\r\n    }\r\n\r\n    // Check for alternate layout inputs\r\n    let alternateLayout: any = null;\r\n    if (isObject(this.UISchema)) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      alternateLayout = cloneDeep(this.UISchema);\r\n    } else if (hasOwn(this.form, 'UISchema')) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      alternateLayout = cloneDeep(this.form.UISchema);\r\n    } else if (hasOwn(this.form, 'uiSchema')) {\r\n      this.jsf.ReactJsonSchemaFormCompatibility = true;\r\n      alternateLayout = cloneDeep(this.form.uiSchema);\r\n    } else if (hasOwn(this.form, 'customFormItems')) {\r\n      this.jsf.JsonFormCompatibility = true;\r\n      alternateLayout = fixJsonFormOptions(cloneDeep(this.form.customFormItems));\r\n    }\r\n\r\n    // if alternate layout found, copy alternate layout options into schema\r\n    if (alternateLayout) {\r\n      JsonPointer.forEachDeep(alternateLayout, (value, pointer) => {\r\n        const schemaPointer = pointer\r\n          .replace(/\\//g, '/properties/')\r\n          .replace(/\\/properties\\/items\\/properties\\//g, '/items/properties/')\r\n          .replace(/\\/properties\\/titleMap\\/properties\\//g, '/titleMap/properties/');\r\n        if (hasValue(value) && hasValue(pointer)) {\r\n          let key = JsonPointer.toKey(pointer);\r\n          const groupPointer = (JsonPointer.parse(schemaPointer) || []).slice(0, -2);\r\n          let itemPointer: string | string[];\r\n\r\n          // If 'ui:order' object found, copy into object schema root\r\n          if (key.toLowerCase() === 'ui:order') {\r\n            itemPointer = [...groupPointer, 'ui:order'];\r\n\r\n            // Copy other alternate layout options to schema 'x-schema-form',\r\n            // (like Angular Schema Form options) and remove any 'ui:' prefixes\r\n          } else {\r\n            if (key.slice(0, 3).toLowerCase() === 'ui:') { key = key.slice(3); }\r\n            itemPointer = [...groupPointer, 'x-schema-form', key];\r\n          }\r\n          if (JsonPointer.has(this.jsf.schema, groupPointer) &&\r\n            !JsonPointer.has(this.jsf.schema, itemPointer)\r\n          ) {\r\n            JsonPointer.set(this.jsf.schema, itemPointer, value);\r\n          }\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'activateForm' function\r\n   *\r\n   * ...continued from 'initializeSchema' function, above\r\n   * If 'schema' has not been initialized (i.e. no schema input found)\r\n   * 6. If layout input - build schema from layout input\r\n   * 7. If data input - build schema from data input\r\n   *\r\n   * Create final layout,\r\n   * build the FormGroup template and the Angular FormGroup,\r\n   * subscribe to changes,\r\n   * and activate the form.\r\n   */\r\n  private activateForm() {\r\n    this.unsubscribeOnActivateForm$.next();\r\n    // If 'schema' not initialized\r\n    if (isEmpty(this.jsf.schema)) {\r\n\r\n      // TODO: If full layout input (with no '*'), build schema from layout\r\n      // if (!this.jsf.layout.includes('*')) {\r\n      //   this.jsf.buildSchemaFromLayout();\r\n      // } else\r\n\r\n      // If data input, build schema from data\r\n      if (!isEmpty(this.jsf.formValues)) {\r\n        this.jsf.buildSchemaFromData();\r\n      }\r\n    }\r\n\r\n    if (!isEmpty(this.jsf.schema)) {\r\n\r\n      // If not already initialized, initialize ajv and compile schema\r\n      this.jsf.compileAjvSchema();\r\n\r\n      // Update all layout elements, add values, widgets, and validators,\r\n      // replace any '*' with a layout built from all schema elements,\r\n      // and update the FormGroup template with any new validators\r\n      this.jsf.buildLayout(this.widgetLibrary);\r\n\r\n      // Build the Angular FormGroup template from the schema\r\n      this.jsf.buildFormGroupTemplate(this.jsf.formValues);\r\n\r\n      // Build the real Angular FormGroup from the FormGroup template\r\n      this.jsf.buildFormGroup();\r\n    }\r\n\r\n    if (this.jsf.formGroup) {\r\n\r\n      // Reset initial form values\r\n      if (!isEmpty(this.jsf.formValues) &&\r\n        this.jsf.formOptions.setSchemaDefaults !== true &&\r\n        this.jsf.formOptions.setLayoutDefaults !== true\r\n      ) {\r\n        this.setFormValues(this.jsf.formValues);\r\n      }\r\n\r\n      // TODO: Figure out how to display calculated values without changing object data\r\n      // See http://ulion.github.io/jsonform/playground/?example=templating-values\r\n      // Calculate references to other fields\r\n      // if (!isEmpty(this.jsf.formGroup.value)) {\r\n      //   forEach(this.jsf.formGroup.value, (value, key, object, rootObject) => {\r\n      //     if (typeof value === 'string') {\r\n      //       object[key] = this.jsf.parseText(value, value, rootObject, key);\r\n      //     }\r\n      //   }, 'top-down');\r\n      // }\r\n\r\n      // Subscribe to form changes to output live data, validation, and errors\r\n      this.dataChangesSubs=this.jsf.dataChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(data => {\r\n        this.onChanges.emit(this.objectWrap ? data['1'] : data);\r\n        if (this.formValuesInput && this.formValuesInput.indexOf('.') === -1) {\r\n          this[`${this.formValuesInput}Change`].emit(this.objectWrap ? data['1'] : data);\r\n        }\r\n      });\r\n\r\n      // Trigger change detection on statusChanges to show updated errors\r\n      this.statusChangesSubs= this.jsf.formGroup.statusChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(() => this.changeDetector.markForCheck());\r\n      this.isValidChangesSubs=this.jsf.isValidChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(isValid => this.isValid.emit(isValid));\r\n      this.validationErrorChangesSubs=this.jsf.validationErrorChanges.pipe(takeUntil(this.unsubscribeOnActivateForm$)).subscribe(err => this.validationErrors.emit(err));\r\n\r\n      // Output final schema, final layout, and initial data\r\n      this.formSchema.emit(this.jsf.schema);\r\n      this.formLayout.emit(this.jsf.layout);\r\n      this.onChanges.emit(this.objectWrap ? this.jsf.data['1'] : this.jsf.data);\r\n\r\n      // If validateOnRender, output initial validation and any errors\r\n      const validateOnRender =\r\n        JsonPointer.get(this.jsf, '/formOptions/validateOnRender');\r\n      if (validateOnRender) { // validateOnRender === 'auto' || true\r\n        const touchAll = (control) => {\r\n          if (validateOnRender === true || hasValue(control.value)) {\r\n            control.markAsTouched();\r\n          }\r\n          Object.keys(control.controls || {})\r\n            .forEach(key => touchAll(control.controls[key]));\r\n        };\r\n        touchAll(this.jsf.formGroup);\r\n        this.isValid.emit(this.jsf.isValid);\r\n        this.validationErrors.emit(this.jsf.ajvErrors);\r\n      }\r\n    }\r\n  }\r\n\r\n}\r\n","<form [autocomplete]=\"jsf?.formOptions?.autocomplete ? 'on' : 'off'\" class=\"json-schema-form\" (ngSubmit)=\"submitForm()\">\r\n  <root-widget [layout]=\"jsf?.layout\"></root-widget>\r\n</form>\r\n<div *ngIf=\"debug || jsf?.formOptions?.debug\">\r\n  Debug output:\r\n  <pre>{{debugOutput}}</pre>\r\n</div>"]}