@ng-formworks/core 19.6.0 → 19.6.2

package/fesm2022/ng-formworks-core.mjs

@@ -10,7 +10,7 @@ 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 { from, Observable, forkJoin, Subject, BehaviorSubject, lastValueFrom } from 'rxjs';
-import { some, isNil, isEmpty as isEmpty$1, isObject as isObject$1, isEqual as isEqual$2 } from 'lodash';
+import { some, isNil, isEmpty as isEmpty$1, pick, isObject as isObject$1, isEqual as isEqual$2 } from 'lodash';
 import isEqual$1 from 'lodash/isEqual';
 import { map, takeUntil } from 'rxjs/operators';
 import omit from 'lodash/omit';
@@ -4588,16 +4588,41 @@ function fixRequiredArrayProperties(schema) {
  * @returns
 
  */
-function convertJSONSchemaIfToCondition(schema, negate = false) {
+function convertJSONSchemaIfToCondition(schema, layoutNode, negate = false) {
     let conditionFun = "";
     let condition = {};
     let notOp = negate ? "!" : "";
+    // expects "dataPointer" to be like "/a/b/c"
+    //TODO-test
+    //dataPointer can be something like /cities/-/name
+    //must end up like model.cities[arrayIndices].name
+    //also check can possibly be nested array like  /cities/-/sites/-/siteName
+    //in this case must probably end up like 
+    // /cities/arrayIndices[0]/sites/arrayIndices[1]/siteName
+    //but it seems evaluatCondition support only one level for now
+    //and uses arrayIndices as the last index only -check?
+    let parentPath = layoutNode.dataPointer ? layoutNode.dataPointer
+        .split("/")
+        .slice(1, -1)
+        .map((part, ind) => {
+        let sep = ind == 0 ? "" : ".";
+        let ret = part == "-" ? "[arrayIndices]" : sep + part;
+        return ret;
+    })
+        .join("")
+        : "";
+    let modelPath = parentPath ? `model.${parentPath}` : "model";
+    let checkPath = modelPath.split(".")
+        .reduce((accumulator, currentPart, index) => {
+        const currentExpression = index === 0 ? currentPart : `${accumulator}.${currentPart}`;
+        return index === 0 ? currentExpression : `${accumulator} && ${currentExpression}`;
+    }, '');
     if (schema.if) {
         Object.keys(schema.if.properties).forEach((ifProp, ind) => {
             let amper = ind > 0 ? "&" : "";
             //Note the model value is first converted to string and so is the condition
             //so that booleans and numbers can also be compared 
-            conditionFun += `${amper}model.${ifProp}+""=='${schema.if.properties[ifProp].const}'`;
+            conditionFun += `${amper} ${checkPath} && ${modelPath}.${ifProp}+""=='${schema.if.properties[ifProp].const}'`;
         });
     }
     condition["functionBody"] = `return ${notOp}(${conditionFun})`;
@@ -5088,7 +5113,8 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                             if (foundKeys && foundKeys.length > 0) {
                                 const keySchemaPointer = `/${ofType}/${ind}`;
                                 //console.log(`found:${keySchemaPointer}`);
-                                let newNodeValue = JsonPointer.get(nodeValue, keySchemaPointer);
+                                let newNodeValue = JsonPointer.get(nodeValue, dataPointer);
+                                //JsonPointer.get(nodeValue, keySchemaPointer);
                                 if (ofType == "oneOf") {
                                     newNodeValue = nodeValue;
                                 }
@@ -5115,16 +5141,52 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                                         //if key is a $oneOf key then it was inserted at the root of the controls
                                         //as form control name will be the full(escaped) path 
                                         const pointerPath = key.startsWith('$oneOf') ? controlItem.schemaPointer : keySchemaPointer;
-                                        let oneOfItemSchema = JsonPointer.get(schema, pointerPath);
-                                        let oneOfItemValue = {};
-                                        oneOfItemValue[key] = controlItem.value?.value;
-                                        if (controlItem.value && !jsf.ajv.validate(oneOfItemSchema, oneOfItemValue)) {
-                                            controlItem.value.value = null;
+                                        let oneOfItemSchema = JsonPointer.get(jsf.schema, controlItem.schemaPointer);
+                                        //JsonPointer.get(schema,pointerPath);
+                                        let dPointer = controlItem.schemaPointer.replace(/(anyOf|allOf|oneOf|none)\/[\d]+\//g, '')
+                                            .replace(/(if|then|else|properties)\//g, '');
+                                        //JsonPointer.toDataPointer(controlItem.schemaPointer,jsf.schema);
+                                        let dVal = JsonPointer.get(nodeValue, dPointer);
+                                        let fkey = key;
+                                        let oneOfItemValue = dVal;
+                                        /*
+                                        if(hasOwn(oneOfItemSchema,"if") && controlItem.schemaPointer
+                                        && controlItem.schemaPointer.indexOf(keySchemaPointer)==0){
+                                          let parts=controlItem.schemaPointer
+                                          .split(keySchemaPointer).join('').split("/")
+                                          let thenOrElse=parts[1];
+                                          fkey=parts[parts.length-1];
+                                          oneOfItemSchema=oneOfItemSchema[thenOrElse];
+                                        }
+                                       
+                                        if(oneOfItemSchema.properties && jsf.formValues===undefined){
+                                          //check if no form data values were supplied
+                                          //then set it to default otherwise to its nodevalue
+                                          oneOfItemValue=oneOfItemSchema.default
+                                          oneOfItemValue[fkey]=oneOfItemSchema.properties[fkey]?.default;
+                                        }
+                                        if(oneOfItemSchema.properties && jsf.formValues!=undefined){
+                                          oneOfItemValue ={};
+                                          //nodeValue||{};
+                                          oneOfItemValue[fkey]=nodeValue&&nodeValue[fkey];
+                                        }
+                                        if(!oneOfItemSchema.properties && jsf.formValues==undefined){
+                                          oneOfItemValue=oneOfItemSchema.default;
+                                        }
+                                          */
+                                        if (hasOwn(controlItem, "value")) {
+                                            if (!jsf.ajv.validate(oneOfItemSchema, oneOfItemValue)) {
+                                                controlItem.value.value = null;
+                                            }
+                                            else {
+                                                ///controlItem.value.value=oneOfItemValue[fkey];
+                                                controlItem.value.value = oneOfItemSchema.properties ? oneOfItemValue[fkey] : oneOfItemValue;
+                                            }
                                         }
                                         //controls[controlKey] = controlItem;
                                         //allOfFGTemplate.controls[key].schemaPointer ||`${schemaPointer}${keySchemaPointer}/${key}`;
                                         //allOfFGTemplate.controls[key].schemaPointer || schemaPointer + keySchemaPointer;
-                                        controls[key] = cloneDeep(allOfFGTemplate.controls[key]);
+                                        ///////controls[key] = cloneDeep(allOfFGTemplate.controls[key]);
                                         //add schemacontrol to root 
                                         //controls[controlKey]=controlItem
                                         controls[`_${ofType}`] = controls[`_${ofType}`] || {};
@@ -5138,7 +5200,7 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                 });
                 jsf.formOptions.fieldsRequired = setRequiredFields(schema, controls);
             }
-            return { controlType, controls, validators };
+            return { controlType, controls, validators, schemaPointer };
         case 'FormArray':
             controls = [];
             const minItems = Math.max(schema.minItems || 0, nodeOptions.get('minItems') || 0);
@@ -5195,7 +5257,7 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                     }
                 }
             }
-            return { controlType, controls, validators };
+            return { controlType, controls, validators, schemaPointer };
         case '$ref':
             const schemaRef = JsonPointer.compile(schema.$ref);
             const dataRef = JsonPointer.toDataPointer(schemaRef, schema);
@@ -5217,7 +5279,7 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                 value: setValues && isPrimitive(nodeValue) ? nodeValue : null,
                 disabled: nodeOptions.get('disabled') || false
             };
-            return { controlType, value, validators };
+            return { controlType, value, validators, schemaPointer };
         //TODO may make an IFThenElse widget or integrate it with the section
         //widget  
         case 'IfThenElse':
@@ -5230,17 +5292,44 @@ function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaP
                         let thenTFGTemplate = buildFormGroupTemplate(jsf, nodeValue, false, schemaPointer + keySchemaPointer, dataPointer, templatePointer + `/controls/${con}`);
                         //NB same property can be in both then and else
                         //so key must be the unique path to control
+                        //let ifItemSchema=JsonPointer.get(schema,keySchemaPointer);
+                        //let ifItemValue;
                         Object.keys(thenTFGTemplate.controls).forEach(key => {
-                            let controlKey = thenTFGTemplate.controls[key].schemaPointer || `${schemaPointer}${keySchemaPointer}/${key}`;
+                            let controlKey = thenTFGTemplate.controls[key].schemaPointer;
+                            ////let controlItem=cloneDeep(thenTFGTemplate.controls[key]);
+                            ////thenTFGTemplate.controls[key].schemaPointer || `${schemaPointer}${keySchemaPointer}/${key}`;
                             controlKey = path2ControlKey(controlKey);
                             let cItem = Object.assign({}, thenTFGTemplate.controls[key]);
-                            cItem.schemaPointer = `${schemaPointer}${keySchemaPointer}/${key}`;
+                            ////cItem.schemaPointer = `${schemaPointer}${keySchemaPointer}/${key}`;
+                            /*
+                           if(ifItemSchema.properties && jsf.formValues===undefined){
+                             //check if no form data values were supplied
+                             //then set it to default otherwise to its nodevalue
+                             ifItemValue=ifItemSchema.default
+                             ifItemValue[key]=ifItemSchema.properties[key]?.default;
+                           }
+                           if(ifItemSchema.properties && jsf.formValues!=undefined){
+                             ifItemValue ={};
+                             //nodeValue||{};
+                             ifItemValue[key]=nodeValue&&nodeValue[key];
+                           }
+                           if(!ifItemSchema.properties && jsf.formValues==undefined){
+                             ifItemValue=ifItemSchema.default;
+                           }
+                           if(hasOwn(cItem,"value")){
+                             if(!jsf.ajv.validate(ifItemSchema,ifItemValue)){
+                               cItem.value.value=null;
+                             }else{
+                               cItem.value.value=ifItemValue[key];
+                             }
+                           }
+                           */
                             controls[controlKey] = cItem;
                         });
                     }
                 });
             }
-            return { controlType, controls, validators };
+            return { controlType, controls, validators, schemaPointer };
         default:
             return null;
     }
@@ -5438,7 +5527,7 @@ function formatFormData(formData, dataMap, recursiveRefMap, arrayMap, returnEmpt
             }
             else if (typeof value !== 'object' || isDate(value) ||
                 (value === null && returnEmptyFields)) {
-                if (genericPointer.substring(0, 2) == "/$") {
+                if (genericPointer.indexOf("/$") >= 0) {
                     return formattedData;
                 }
                 console.error('formatFormData error: ' +
@@ -5512,6 +5601,9 @@ function getControl(formGroup, dataPointer, returnGroup = false, schemaPointer)
         else if (hasOwn(subGroup, key)) {
             subGroup = subGroup[key];
         }
+        else if (schemaPointer && hasOwn(subGroup, path2ControlKey(schemaPointer))) {
+            subGroup = subGroup[path2ControlKey(schemaPointer)];
+        }
         else {
             console.error(`getControl error: Unable to find "${key}" item in FormGroup.`);
             console.error(dataPointer);
@@ -5752,7 +5844,6 @@ function buildLayout_original(jsf, widgetLibrary) {
                 schemaPointer = JsonPointer.toSchemaPointer(shortDataPointer, jsf.schema);
                 nodeDataMap.set('schemaPointer', schemaPointer);
             }
-            nodeDataMap.set('disabled', !!newNode.options.disabled);
             nodeSchema = JsonPointer.get(jsf.schema, schemaPointer);
             if (nodeSchema) {
                 if (!hasOwn(newNode, 'type')) {
@@ -5773,6 +5864,7 @@ function buildLayout_original(jsf, widgetLibrary) {
                 newNode.dataType =
                     nodeSchema.type || (hasOwn(nodeSchema, '$ref') ? '$ref' : null);
                 updateInputOptions(newNode, nodeSchema, jsf);
+                nodeDataMap.set('disabled', !!newNode.options.disabled);
                 // Present checkboxes as single control, rather than array
                 if (newNode.type === 'checkboxes' && hasOwn(nodeSchema, 'items')) {
                     updateInputOptions(newNode, nodeSchema.items, jsf);
@@ -6200,6 +6292,37 @@ function fixNestedArrayLayout(options) {
  * //
  */
 function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPointer = '', dataPointer = '', arrayItem = false, arrayItemType = null, removable = null, forRefLibrary = false, dataPointerPrefix = '', jsonSchema) {
+    function applyITEConditions(builtLayout, schPointer, keySchemaPointer, negateClause, parentLayout) {
+        if (builtLayout) {
+            if (parentLayout && parentLayout.isITEItem && parentLayout.options.condition) {
+                return;
+            }
+            if (isArray(builtLayout)) {
+                builtLayout.forEach(item => {
+                    item.isITEItem = true;
+                    item.options.condition = convertJSONSchemaIfToCondition(schema, item, negateClause);
+                    applyITEConditions(item, schPointer, keySchemaPointer, negateClause, builtLayout);
+                    //item.schemaPointer = schPointer + keySchemaPointer + item.dataPointer;
+                    //item.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
+                    //newSection.push(item);
+                });
+            }
+            else if (hasOwn(builtLayout, "items")) {
+                applyITEConditions(builtLayout.items, schPointer, keySchemaPointer, negateClause, builtLayout);
+                // builtLayout.items.forEach(item => {
+                //   item.isITEItem=true;
+                //   item.options.condition = convertJSONSchemaIfToCondition(schema,item, negateClause);
+                //   applyITEConditions(item,schPointer,keySchemaPointer,negateClause)
+                // });
+            }
+            else {
+                builtLayout.isITEItem = true;
+                //builtLayout.schemaPointer = `${schPointer}${keySchemaPointer}/${builtLayout.name}`;
+                builtLayout.options.condition = convertJSONSchemaIfToCondition(schema, builtLayout, negateClause);
+                //newSection.push(builtLayout)
+            }
+        }
+    }
     const jsSchema = jsonSchema || jsf.schema;
     const schema = JsonPointer.get(jsSchema, schemaPointer);
     //JsonPointer.get(jsf.schema, schemaPointer);
@@ -6237,6 +6360,7 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
     if (!jsf.dataMap.has(shortDataPointer)) {
         jsf.dataMap.set(shortDataPointer, new Map());
     }
+    updateInputOptions(newNode, schema, jsf);
     const nodeDataMap = jsf.dataMap.get(shortDataPointer);
     if (!nodeDataMap.has('inputType')) {
         nodeDataMap.set('schemaPointer', schemaPointer);
@@ -6244,7 +6368,7 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
         nodeDataMap.set('widget', newNode.widget);
         nodeDataMap.set('disabled', !!newNode.options.disabled);
     }
-    updateInputOptions(newNode, schema, jsf);
+    //updateInputOptions(newNode, schema, jsf);
     if (!newNode.options.title && newNode.name && !/^\d+$/.test(newNode.name)) {
         newNode.options.title = fixTitle(newNode.name);
     }
@@ -6272,6 +6396,7 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
                     '/properties/' + key : '/additionalProperties';
                 const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, isObject(nodeValue) ? nodeValue[key] : null, schemaPointer + keySchemaPointer, dataPointer + '/' + key, false, null, null, forRefLibrary, dataPointerPrefix);
                 if (innerItem) {
+                    innerItem.schemaPointer = schemaPointer + keySchemaPointer;
                     if (isInputRequired(schema, '/' + key)) {
                         innerItem.options.required = true;
                         jsf.fieldsRequired = true;
@@ -6296,38 +6421,50 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
                     }
                     schema[ofType].forEach((ofItem, ind) => {
                         const keySchemaPointer = `/${ofType}/${ind}`;
-                        const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, ofItem, schemaPointer + keySchemaPointer, dataPointer, false, null, null, forRefLibrary, dataPointerPrefix);
+                        const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, ofItem, schemaPointer + keySchemaPointer, dataPointer, false, null, null, ofType == "oneOf" /*forRefLibrary*/, dataPointerPrefix);
                         if (innerItem) {
                             //newSection.push(innerItem);
                             if (innerItem.items) {
                                 innerItem.items.forEach(innerItemLevel2 => {
                                     const l2SchemaPointer = hasOwn(ofItem, 'properties') ?
                                         '/properties/' + innerItemLevel2.name : innerItemLevel2.name;
-                                    innerItemLevel2.oneOfPointer = schemaPointer + keySchemaPointer + l2SchemaPointer;
-                                    innerItemLevel2.schemaPointer = innerItemLevel2.oneOfPointer;
+                                    //innerItemLevel2.oneOfPointer =  schemaPointer + keySchemaPointer + l2SchemaPointer;
+                                    // innerItemLevel2.schemaPointer=innerItemLevel2.schemaPointer; 
+                                    innerItemLevel2.oneOfPointer = innerItemLevel2.schemaPointer;
                                 });
                             }
+                            //TODO review-will never reach here if forRefLibrary==true
                             if (isArray(innerItem)) {
+                                let outerOneOfItemTpl = cloneDeep(newNode);
+                                outerOneOfItemTpl;
                                 innerItem.forEach(item => {
                                     const l2SchemaPointer = hasOwn(ofItem, 'properties') ?
                                         '/properties/' + item.name : item.name;
                                     if (outerOneOfItem) {
-                                        item.oneOfPointer = schemaPointer + keySchemaPointer + l2SchemaPointer;
+                                        ////item.oneOfPointer =  schemaPointer + keySchemaPointer + l2SchemaPointer;
                                         //schemaPointer + keySchemaPointer + item.dataPointer;
-                                        item.schemaPointer = item.oneOfPointer;
-                                        outerOneOfItem.items = outerOneOfItem.items || [];
+                                        ////item.schemaPointer=item.oneOfPointer; 
+                                        /*
+                                        outerOneOfItem.items=outerOneOfItem.items||[];
                                         outerOneOfItem.items.push(item);
+                                        */
+                                        outerOneOfItemTpl.items = outerOneOfItemTpl.items || [];
+                                        outerOneOfItemTpl.items.push(item);
                                     }
                                     else {
                                         newSection.push(item);
                                     }
                                 });
+                                if (outerOneOfItem) {
+                                    outerOneOfItem.items = outerOneOfItem.items || [];
+                                    outerOneOfItem.items.push(outerOneOfItemTpl);
+                                }
                                 //TODO test-might not work for more than 2 levels of nesting
                             }
                             else {
                                 if (outerOneOfItem) {
                                     innerItem.oneOfPointer = schemaPointer + keySchemaPointer; // + innerItem.dataPointer;
-                                    innerItem.schemaPointer = innerItem.oneOfPointer;
+                                    ////innerItem.schemaPointer=innerItem.oneOfPointer; 
                                     outerOneOfItem.items = outerOneOfItem.items || [];
                                     outerOneOfItem.items.push(innerItem);
                                 }
@@ -6346,16 +6483,17 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
                         const negateClause = con == "else";
                         const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, nodeValue.then, schemaPointer + keySchemaPointer, dataPointer, false, null, null, forRefLibrary, dataPointerPrefix);
                         if (innerItem) {
+                            applyITEConditions(innerItem, schemaPointer, keySchemaPointer, negateClause);
                             if (isArray(innerItem)) {
                                 innerItem.forEach(item => {
-                                    item.schemaPointer = schemaPointer + keySchemaPointer + item.dataPointer;
-                                    item.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
+                                    //item.schemaPointer = schemaPointer + keySchemaPointer + item.dataPointer;
+                                    //item.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
                                     newSection.push(item);
                                 });
                             }
                             else {
-                                innerItem.schemaPointer = schemaPointer + keySchemaPointer + innerItem.dataPointer;
-                                innerItem.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
+                                //innerItem.schemaPointer = schemaPointer + keySchemaPointer + innerItem.dataPointer;
+                                //innerItem.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
                                 newSection.push(innerItem);
                             }
                         }
@@ -6572,17 +6710,18 @@ function buildLayoutFromSchema(jsf, widgetLibrary, nodeValue = null, schemaPoint
                 const negateClause = con == "else";
                 const innerItem = buildLayoutFromSchema(jsf, widgetLibrary, nodeValue.then, schemaPointer + keySchemaPointer, dataPointer, false, null, null, forRefLibrary, dataPointerPrefix);
                 if (innerItem) {
+                    applyITEConditions(innerItem, schemaPointer, keySchemaPointer, negateClause);
                     if (isArray(innerItem)) {
                         innerItem.forEach(item => {
-                            item.schemaPointer = schemaPointer + keySchemaPointer + item.dataPointer;
-                            item.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
+                            //item.schemaPointer = schemaPointer + keySchemaPointer + item.dataPointer;
+                            //item.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
                             newSection.push(item);
                             newNode = newSection;
                         });
                     }
                     else {
-                        innerItem.schemaPointer = schemaPointer + keySchemaPointer + innerItem.dataPointer;
-                        innerItem.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
+                        //innerItem.schemaPointer = schemaPointer + keySchemaPointer + innerItem.dataPointer;
+                        //innerItem.options.condition = convertJSONSchemaIfToCondition(schema, negateClause);
                         newNode = innerItem;
                     }
                 }
@@ -7331,7 +7470,8 @@ class JsonSchemaFormService {
         ctx.formControl = this.getFormControl(ctx);
         //introduced to check if the node  is part of ITE conditional
         //then change or add the control
-        if (layoutNode?.schemaPointer) {
+        if (layoutNode?.schemaPointer && layoutNode.isITEItem ||
+            (layoutNode?.schemaPointer && layoutNode?.oneOfPointer)) {
             //before changing control, need to set the new data type for data formatting
             const schemaType = this.dataMap.get(layoutNode?.dataPointer).get("schemaType");
             if (schemaType != layoutNode.dataType) {
@@ -7372,11 +7512,24 @@ class JsonSchemaFormService {
         }
         //if this is a ITE conditional field, the value would not have been
         //set, as the control would only be initialized when the condition is true 
-        if (ctx.options?.condition) {
-            const value = JsonPointer.has(this.formValues, layoutNode.dataPointer)
-                ? JsonPointer.get(this.formValues, layoutNode.dataPointer)
-                : ctx.options?.default;
-            ctx.formControl?.setValue(value);
+        //TODO-review need to decide which of the data sets between data,formValues and default 
+        //to use for the value
+        if (ctx.options?.condition || layoutNode?.oneOfPointer) {
+            const dataPointer = this.getDataPointer(ctx);
+            const controlValue = ctx.formControl.value;
+            const dataValue = JsonPointer.has(this.data, dataPointer) ?
+                JsonPointer.get(this.data, dataPointer) : undefined;
+            const formValue = JsonPointer.has(this.formValues, dataPointer) ?
+                JsonPointer.get(this.formValues, dataPointer) : undefined;
+            const schemaDefault = ctx.options?.default;
+            //if initial formValues was supplied and controlValue matches formValue then likely
+            //control was initially created with the formValue then set value to data value
+            //if no formValues was supplied and controlValue matches schemaDefault then likely
+            //control was initially created with the default then set value to data value
+            const value = this.formValues && isEqual$1(formValue, controlValue) ? dataValue
+                : !this.formValues && isEqual$1(schemaDefault, controlValue) ? dataValue
+                    : schemaDefault;
+            ctx.formControl?.patchValue(value);
         }
         return ctx.boundControl;
     }
@@ -7492,7 +7645,9 @@ class JsonSchemaFormService {
             ctx.layoutNode().type === '$ref') {
             return null;
         }
-        return getControl(this.formGroup, this.getDataPointer(ctx), false, ctx.layoutNode()?.schemaPointer);
+        const schemaPointer = ctx.layoutNode()?.isITEItem ? ctx.layoutNode()?.schemaPointer : null;
+        const oneOfPointer = ctx.layoutNode()?.oneOfPointer;
+        return getControl(this.formGroup, this.getDataPointer(ctx), false, schemaPointer || oneOfPointer);
     }
     setFormControl(ctx, control) {
         if (!ctx || !ctx.layoutNode ||
@@ -7508,14 +7663,18 @@ class JsonSchemaFormService {
             ctx.layoutNode().type === '$ref') {
             return null;
         }
-        const control = getControl(this.formGroup, this.getDataPointer(ctx));
+        const schemaPointer = ctx.layoutNode()?.isITEItem ? ctx.layoutNode()?.schemaPointer : null;
+        const oneOfPointer = ctx.layoutNode()?.oneOfPointer;
+        const control = getControl(this.formGroup, this.getDataPointer(ctx), false, schemaPointer || oneOfPointer);
         return control ? control.value : null;
     }
     getFormControlGroup(ctx) {
         if (!ctx || !ctx.layoutNode || !isDefined(ctx.layoutNode().dataPointer)) {
             return null;
         }
-        return getControl(this.formGroup, this.getDataPointer(ctx), true, ctx.layoutNode()?.schemaPointer);
+        const schemaPointer = ctx.layoutNode()?.isITEItem ? ctx.layoutNode()?.schemaPointer : null;
+        const oneOfPointer = ctx.layoutNode()?.oneOfPointer;
+        return getControl(this.formGroup, this.getDataPointer(ctx), true, schemaPointer || oneOfPointer);
     }
     getFormControlName(ctx) {
         if (!ctx || !ctx.layoutNode ||
@@ -7868,6 +8027,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
                 }]
         }] });
 
+///NB issue caused by sortablejs when it its destroyed
+//this mainly affects checkboxes coupled with conditions
+//-the value is rechecked
+//-see https://github.com/SortableJS/Sortable/issues/1052#issuecomment-369613072
 class CheckboxComponent {
     constructor() {
         this.jsf = inject(JsonSchemaFormService);
@@ -7883,7 +8046,8 @@ class CheckboxComponent {
         this.options = this.layoutNode().options || {};
         this.jsf.initializeControl(this);
         if (this.controlValue === null || this.controlValue === undefined) {
-            this.controlValue = this.options.title;
+            this.controlValue = false;
+            this.jsf.updateValue(this, this.falseValue);
         }
     }
     updateValue(event) {
@@ -7913,7 +8077,7 @@ class CheckboxComponent {
         type="checkbox">
       <input *ngIf="!boundControl"
         [attr.aria-describedby]="'control' + layoutNode()?._id + 'Status'"
-        [checked]="isChecked ? 'checked' : null"
+        [checked]="isChecked"
         [class]="(options?.fieldHtmlClass || '') + (isChecked ?
           (' ' + (options?.activeClass || '') + ' ' + (options?.style?.selected || '')) :
           (' ' + (options?.style?.unselected || '')))"
@@ -7950,7 +8114,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
         type="checkbox">
       <input *ngIf="!boundControl"
         [attr.aria-describedby]="'control' + layoutNode()?._id + 'Status'"
-        [checked]="isChecked ? 'checked' : null"
+        [checked]="isChecked"
         [class]="(options?.fieldHtmlClass || '') + (isChecked ?
           (' ' + (options?.activeClass || '') + ' ' + (options?.style?.selected || '')) :
           (' ' + (options?.style?.unselected || '')))"
@@ -8756,14 +8920,30 @@ class OneOfComponent {
                             let parts = controlName.split('$');
                             let fieldName = parts[parts.length - 1];
                             let controlValue = this.jsf.formGroup.controls[controlName].value;
-                            if (isObject$1(formValue) && hasOwn(formValue, fieldName) &&
-                                formValue[fieldName] == controlValue
-                            //formValue[fieldName]||controlValue
-                            ) {
-                                foundInd = ind;
+                            let controlSchema = JsonPointer.get(this.jsf.schema, parts.join("/"));
+                            let schemaPointer = parts.join("/");
+                            let dPointer = schemaPointer.replace(/(anyOf|allOf|oneOf|none)\/[\d]+\//g, '')
+                                .replace(/(if|then|else|properties)\//g, '');
+                            //JsonPointer.toDataPointer(parts.join("/"),this.jsf.schema);
+                            let dVal = JsonPointer.get(this.jsf.formValues, dPointer);
+                            let compareVal = dVal; //formValue;
+                            //compare only values that are in the subschema properties
+                            if (controlSchema && controlSchema.properties) {
+                                compareVal = isObject$1(dVal) && hasOwn(dVal, fieldName) ?
+                                    pick(dVal[fieldName], Object.keys(controlSchema.properties))
+                                    : pick(dVal, Object.keys(controlSchema.properties));
+                            }
+                            /*
+                            if(isObject(compareVal) && hasOwn(compareVal,fieldName) &&
+                            isEqual(compareVal[fieldName],controlValue)
+                          ){
+                              foundInd=ind;
+                            }else //if(formValue || controlValue){
+                            if(isEqual(compareVal,controlValue)){
+                              foundInd=ind;
                             }
-                            else //if(formValue || controlValue){
-                             if (isEqual$2(formValue, controlValue)) {
+                            */
+                            if (isEqual$2(compareVal, controlValue)) {
                                 foundInd = ind;
                             }
                         });
@@ -9118,6 +9298,63 @@ class RootComponent {
     }
     sortableInit(sortable) {
         this.sortableObj = sortable;
+        ///NB issue caused by sortablejs when it its destroyed
+        //this mainly affects checkboxes coupled with conditions
+        //-the value is rechecked
+        //-see https://github.com/SortableJS/Sortable/issues/1052#issuecomment-369613072
+        /* attempt to monkey patch sortable js
+        const originalMethod = sortable._nulling;
+        let zone=this.zone;
+        sortable._nulling=function() {
+          console.log(`pluginEvent 2 ${pluginEvent}`)
+                zone.runOutsideAngular(() => {
+                  console.log(`pluginEvent3 ${pluginEvent}`)
+          pluginEvent('nulling', this);
+      
+          rootEl =
+          dragEl =
+          parentEl =
+          ghostEl =
+          nextEl =
+          cloneEl =
+          lastDownEl =
+          cloneHidden =
+      
+          tapEvt =
+          touchEvt =
+      
+          moved =
+          newIndex =
+          newDraggableIndex =
+          oldIndex =
+          oldDraggableIndex =
+      
+          lastTarget =
+          lastDirection =
+      
+          putSortable =
+          activeGroup =
+          Sortable.dragged =
+          Sortable.ghost =
+          Sortable.clone =
+          Sortable.active = null;
+      
+        
+            let el = this.el;
+            savedInputChecked.forEach(function (checkEl) {
+              if (el.contains(checkEl)) {
+                checkEl.checked = true;
+              }
+            });
+        
+            savedInputChecked.length =
+            lastDx =
+            lastDy = 0;
+    
+          })
+    
+        }.bind(sortable)
+        */
     }
     isDraggable(node) {
         let result = node.arrayItem && node.type !== '$ref' &&
@@ -10692,7 +10929,9 @@ class JsonSchemaFormComponent {
    */
     initializeAjv() {
         const form = this.form();
-        const ajvOptions = cloneDeep(this.ajvOptions()) || cloneDeep(form.ajvOptions);
+        const ajvOptions = cloneDeep(this.ajvOptions()) ||
+            (form && hasOwn(form, 'ajvOptions') && isObject(form.ajvOptions)
+                && cloneDeep(form.ajvOptions));
         if (ajvOptions) {
             this.ajvInstanceName = this.jsf.createAndRegisterAjvInstance(ajvOptions).name;
         }