@remoteoss/json-schema-form 0.4.3-beta.0 → 0.4.4-dev.20230829101351

package/dist/index.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.4.3-beta.0
- Generated: Wed, 09 Aug 2023 08:39:30 GMT
+ NPM Package: @remoteoss/json-schema-form@0.4.4-dev.20230829101351
+ Generated: Tue, 29 Aug 2023 10:14:13 GMT
 
  MIT License
 
@@ -67,8 +67,8 @@ function hasProperty(object2, propertyName) {
 }
 
 // src/checkIfConditionMatches.js
-function checkIfConditionMatches(node, formValues, formFields) {
-  return Object.keys(node.if.properties).every((name) => {
+function checkIfConditionMatches(node, formValues, formFields, validations) {
+  return Object.keys(node.if.properties ?? {}).every((name) => {
     const currentProperty = node.if.properties[name];
     const value = formValues[name];
     const hasEmptyValue = typeof value === "undefined" || // NOTE: This is a "Remote API" dependency, as empty fields are sent as "null".
@@ -94,7 +94,8 @@ function checkIfConditionMatches(node, formValues, formFields) {
       return checkIfConditionMatches(
         { if: currentProperty },
         formValues[name],
-        getField(name, formFields).fields
+        getField(name, formFields).fields,
+        validations
       );
     }
     const field = getField(name, formFields);
@@ -110,6 +111,23 @@ function checkIfConditionMatches(node, formValues, formFields) {
     );
   });
 }
+function checkIfMatchesValidationsAndComputedValues(node, formValues, validations, parentID) {
+  const validationsMatch = Object.entries(node.if.validations ?? {}).every(([name, property]) => {
+    const currentValue = validations.getScope(parentID).evaluateValidationRuleInCondition(name, formValues);
+    if (Object.hasOwn(property, "const") && currentValue === property.const)
+      return true;
+    return false;
+  });
+  const computedValuesMatch = Object.entries(node.if.computedValues ?? {}).every(
+    ([name, property]) => {
+      const currentValue = validations.getScope(parentID).evaluateComputedValueRuleInCondition(name, formValues);
+      if (Object.hasOwn(property, "const") && currentValue === property.const)
+        return true;
+      return false;
+    }
+  );
+  return computedValuesMatch && validationsMatch;
+}
 
 // src/internals/helpers.js
 import merge from "lodash/fp/merge";
@@ -370,6 +388,9 @@ function _composeFieldCustomClosure(defaultComposeFn) {
   };
 }
 
+// src/jsonLogic.js
+import jsonLogic from "json-logic-js";
+
 // src/yupSchema.js
 import flow from "lodash/flow";
 import noop from "lodash/noop";
@@ -497,7 +518,7 @@ var getYupSchema = ({ inputType, ...field }) => {
   }
   return yupSchemas[inputType] || yupSchemasToJsonTypes[jsonType];
 };
-function buildYupSchema(field, config) {
+function buildYupSchema(field, config, validations) {
   const { inputType, jsonType: jsonTypeValue, errorMessage = {}, ...propertyFields } = field;
   const isCheckboxBoolean = typeof propertyFields.checkboxValue === "boolean";
   let baseSchema;
@@ -570,6 +591,13 @@ function buildYupSchema(field, config) {
       }) : true
     );
   }
+  function withConst(yupSchema) {
+    return yupSchema.test(
+      "isConst",
+      errorMessage.const ?? errorMessageFromConfig.const ?? `The only accepted value is ${propertyFields.const}.`,
+      (value) => propertyFields.required === false && value === void 0 || value === null || value === propertyFields.const
+    );
+  }
   function withBaseSchema() {
     const customErrorMsg = errorMessage.type || errorMessageFromConfig.type;
     if (customErrorMsg) {
@@ -590,7 +618,8 @@ function buildYupSchema(field, config) {
             ...fieldSetfield,
             inputType: fieldSetfield.type
           },
-          config
+          { ...config, parentID: field.name },
+          validations
         )();
       }
     });
@@ -601,7 +630,11 @@ function buildYupSchema(field, config) {
       propertyFields.nthFieldGroup.fields().reduce(
         (schema, groupArrayField) => ({
           ...schema,
-          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
+          [groupArrayField.name]: buildYupSchema(
+            groupArrayField,
+            { ...config, parentID: `${propertyFields.nthFieldGroup.name}[]` },
+            validations
+          )()
         }),
         {}
       )
@@ -637,6 +670,14 @@ function buildYupSchema(field, config) {
   if (propertyFields.accept) {
     validators.push(withFileFormat);
   }
+  if (propertyFields.const) {
+    validators.push(withConst);
+  }
+  if (propertyFields.requiredValidations) {
+    propertyFields.requiredValidations.forEach(
+      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, validations, config }))
+    );
+  }
   return flow(validators);
 }
 function getNoSortEdges(fields = []) {
@@ -647,26 +688,322 @@ function getNoSortEdges(fields = []) {
     return list;
   }, []);
 }
-function getSchema(fields = [], config) {
+function getSchema(fields = [], config, validations) {
   const newSchema = {};
   fields.forEach((field) => {
     if (field.schema) {
       if (field.name) {
         if (field.inputType === supportedTypes.FIELDSET) {
-          const fieldsetSchema = buildYupSchema(field, config)();
+          const fieldsetSchema = buildYupSchema(
+            field,
+            { ...config, parentID: field.name },
+            validations
+          )();
           newSchema[field.name] = fieldsetSchema;
         } else {
           newSchema[field.name] = field.schema;
         }
       } else {
-        Object.assign(newSchema, getSchema(field.fields, config));
+        Object.assign(newSchema, getSchema(field.fields, config, validations));
       }
     }
   });
   return newSchema;
 }
-function buildCompleteYupSchema(fields, config) {
-  return object().shape(getSchema(fields, config), getNoSortEdges(fields));
+function buildCompleteYupSchema(fields, config, validations) {
+  return object().shape(getSchema(fields, config, validations), getNoSortEdges(fields));
+}
+
+// src/jsonLogic.js
+function createValidationChecker(schema) {
+  const scopes = /* @__PURE__ */ new Map();
+  function createScopes(jsonSchema, key = "root") {
+    const sampleEmptyObject = buildSampleEmptyObject(schema);
+    scopes.set(key, createValidationsScope(jsonSchema));
+    Object.entries(jsonSchema?.properties ?? {}).filter(([, property]) => property.type === "object" || property.type === "array").forEach(([key2, property]) => {
+      if (property.type === "array") {
+        createScopes(property.items, `${key2}[]`);
+      }
+      createScopes(property, key2);
+    });
+    validateInlineRules(jsonSchema, sampleEmptyObject);
+  }
+  createScopes(schema);
+  return {
+    scopes,
+    getScope(name = "root") {
+      return scopes.get(name);
+    }
+  };
+}
+function createValidationsScope(schema) {
+  const validationMap = /* @__PURE__ */ new Map();
+  const computedValuesMap = /* @__PURE__ */ new Map();
+  const logic = schema?.["x-jsf-logic"] ?? {
+    validations: {},
+    computedValues: {}
+  };
+  const validations = Object.entries(logic.validations ?? {});
+  const computedValues = Object.entries(logic.computedValues ?? {});
+  const sampleEmptyObject = buildSampleEmptyObject(schema);
+  validations.forEach(([id, validation]) => {
+    if (!validation.rule) {
+      throw Error(`Missing rule for validation with id of: "${id}".`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
+    validationMap.set(id, validation);
+  });
+  computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`Missing rule for computedValue with id of: "${id}".`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
+    computedValuesMap.set(id, computedValue);
+  });
+  function evaluateValidation(rule, values) {
+    return jsonLogic.apply(rule, clean(values));
+  }
+  return {
+    validationMap,
+    computedValuesMap,
+    evaluateValidation,
+    evaluateValidationRuleInCondition(id, values) {
+      const validation = validationMap.get(id);
+      if (validation === void 0)
+        throw Error(`"${id}" validation in if condition doesn't exist.`);
+      return evaluateValidation(validation.rule, values);
+    },
+    evaluateComputedValueRuleForField(id, values, fieldName) {
+      const validation = computedValuesMap.get(id);
+      if (validation === void 0)
+        throw Error(`"${id}" computedValue in field "${fieldName}" doesn't exist.`);
+      return evaluateValidation(validation.rule, values);
+    },
+    evaluateComputedValueRuleInCondition(id, values) {
+      const validation = computedValuesMap.get(id);
+      if (validation === void 0)
+        throw Error(`"${id}" computedValue in if condition doesn't exist.`);
+      return evaluateValidation(validation.rule, values);
+    }
+  };
+}
+function clean(values = {}) {
+  return Object.entries(values).reduce((prev, [key, value]) => {
+    return { ...prev, [key]: value === void 0 ? null : value };
+  }, {});
+}
+function yupSchemaWithCustomJSONLogic({ field, validations, config, id }) {
+  const { parentID = "root" } = config;
+  const validation = validations.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(`Validation "${id}" required for "${field.name}" doesn't exist.`);
+  }
+  return (yupSchema) => yupSchema.test(
+    `${field.name}-validation-${id}`,
+    validation?.errorMessage ?? "This field is invalid.",
+    (value, { parent }) => {
+      if (value === void 0 && !field.required)
+        return true;
+      return jsonLogic.apply(validation.rule, parent);
+    }
+  );
+}
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  validations,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return validations.getScope(parentID).evaluateComputedValueRuleForField(key.trim(), formValues, fieldName);
+    });
+  } else if (typeof toReplace === "object") {
+    const { value, ...rules } = toReplace;
+    if (Object.keys(rules).length > 1 && !value)
+      throw Error("Cannot define multiple rules without a template string with key `value`.");
+    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
+      const computedValue = validations.getScope(parentID).evaluateValidation(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return validations.getScope(parentID).evaluateComputedValueRuleForField(key.trim(), formValues, fieldName);
+    });
+  }
+}
+function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
+  return ({ validations, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
+    const attributes = Object.fromEntries(
+      Object.entries(computedAttributes).map(handleComputedAttribute(validations, formValues, parentID, name)).filter(([, value]) => value !== null)
+    );
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        validations
+      )
+    };
+  };
+}
+function handleComputedAttribute(validations, formValues, parentID, name) {
+  return ([key, value]) => {
+    if (key === "description")
+      return [key, replaceHandlebarsTemplates({ value, validations, formValues, parentID, name })];
+    if (key === "title") {
+      return [
+        "label",
+        replaceHandlebarsTemplates({ value, validations, formValues, parentID, name })
+      ];
+    }
+    if (key === "const")
+      return [
+        key,
+        validations.getScope(parentID).evaluateComputedValueRuleForField(value, formValues, name)
+      ];
+    if (key === "x-jsf-errorMessage") {
+      return [
+        "errorMessage",
+        handleNestedObjectForComputedValues(value, formValues, parentID, validations, name)
+      ];
+    }
+    if (typeof value === "string") {
+      return [
+        key,
+        validations.getScope(parentID).evaluateComputedValueRuleForField(value, formValues, name)
+      ];
+    }
+    if (key === "x-jsf-presentation" && value.statement) {
+      return [
+        "statement",
+        handleNestedObjectForComputedValues(
+          value.statement,
+          formValues,
+          parentID,
+          validations,
+          name
+        )
+      ];
+    }
+    if (typeof value === "object" && value.rule) {
+      return [key, validations.getScope(parentID).evaluateValidation(value.rule, formValues)];
+    }
+  };
+}
+function handleNestedObjectForComputedValues(values, formValues, parentID, validations, name) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, validations, formValues, parentID, name })];
+    })
+  );
+}
+function processJSONLogicNode({
+  node,
+  formFields,
+  formValues,
+  accRequired,
+  parentID,
+  validations
+}) {
+  const requiredFields = new Set(accRequired);
+  if (node.allOf) {
+    node.allOf.map(
+      (allOfNode) => processJSONLogicNode({ node: allOfNode, formValues, formFields, validations, parentID })
+    ).forEach(({ required: allOfItemRequired }) => {
+      allOfItemRequired.forEach(requiredFields.add, requiredFields);
+    });
+  }
+  if (node.if) {
+    const matchesPropertyCondition = checkIfConditionMatches(
+      node,
+      formValues,
+      formFields,
+      validations
+    );
+    const matchesValidationsAndComputedValues = checkIfMatchesValidationsAndComputedValues(
+      node,
+      formValues,
+      validations,
+      parentID
+    );
+    const isConditionMatch = matchesPropertyCondition && matchesValidationsAndComputedValues;
+    if (isConditionMatch && node.then) {
+      const { required: branchRequired } = processNode({
+        node: node.then,
+        formValues,
+        formFields,
+        accRequired,
+        validations
+      });
+      branchRequired.forEach((field) => requiredFields.add(field));
+    }
+    if (!isConditionMatch && node.else) {
+      const { required: branchRequired } = processNode({
+        node: node.else,
+        formValues,
+        formFields,
+        accRequired: requiredFields,
+        validations
+      });
+      branchRequired.forEach((field) => requiredFields.add(field));
+    }
+  }
+  return { required: requiredFields };
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
+  }
+  for (const key in schema.properties) {
+    if (schema.properties[key].type === "object") {
+      sample[key] = buildSampleEmptyObject(schema.properties[key]);
+    } else if (schema.properties[key].type === "array") {
+      const itemSchema = schema.properties[key].items;
+      sample[key] = buildSampleEmptyObject(itemSchema);
+    } else {
+      sample[key] = true;
+    }
+  }
+  return sample;
+}
+function validateInlineRules(jsonSchema, sampleEmptyObject) {
+  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
+  Object.entries(properties).filter(([, property]) => property["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property]) => {
+    Object.entries(property["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
+      Object.values(item).forEach((rule) => {
+        checkRuleIntegrity(
+          rule,
+          fieldName,
+          sampleEmptyObject,
+          (item2) => `"${item2.var}" in inline rule in property "${fieldName}.x-jsf-logic-computedAttrs.${key}" does not exist as a JSON schema property.`
+        );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `"${item.var}" in rule "${id}" does not exist as a JSON schema property.`) {
+  Object.values(rule ?? {}).map((subRule) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    subRule.map((item) => {
+      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
+      if (isVar) {
+        const exists = jsonLogic.apply({ var: removeIndicesFromPath(item.var) }, data);
+        if (exists === null) {
+          throw Error(errorMessage(item));
+        }
+      } else {
+        checkRuleIntegrity(item, id, data);
+      }
+    });
+  });
+}
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(/\.\d+\./g, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
 }
 
 // src/helpers.js
@@ -676,8 +1013,8 @@ function hasType(type, typeName) {
 function getField(fieldName, fields) {
   return fields.find(({ name }) => name === fieldName);
 }
-function validateFieldSchema(field, value) {
-  const validator = buildYupSchema(field);
+function validateFieldSchema(field, value, validations) {
+  const validator = buildYupSchema(field, {}, validations);
   return validator().isValidSync(value);
 }
 function compareFormValueWithSchemaValue(formValue, schemaValue) {
@@ -742,7 +1079,7 @@ function getPrefillValues(fields, initialValues = {}) {
   });
   return initialValues;
 }
-function updateField(field, requiredFields, node, formValues) {
+function updateField(field, requiredFields, node, formValues, validations, config) {
   if (!field) {
     return;
   }
@@ -764,8 +1101,25 @@ function updateField(field, requiredFields, node, formValues) {
       }
     }
   });
+  if (field.getComputedAttributes) {
+    const computedFieldValues = field.getComputedAttributes({
+      field,
+      isRequired: fieldIsRequired,
+      node,
+      formValues,
+      config,
+      validations
+    });
+    updateValues(computedFieldValues);
+  }
   if (field.calculateConditionalProperties) {
-    const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
+    const newFieldValues = field.calculateConditionalProperties(
+      fieldIsRequired,
+      node,
+      validations,
+      config,
+      formValues
+    );
     updateValues(newFieldValues);
   }
   if (field.calculateCustomValidationProperties) {
@@ -777,33 +1131,46 @@ function updateField(field, requiredFields, node, formValues) {
     updateValues(newFieldValues);
   }
 }
-function processNode(node, formValues, formFields, accRequired = /* @__PURE__ */ new Set()) {
+function processNode({
+  node,
+  formValues,
+  formFields,
+  accRequired = /* @__PURE__ */ new Set(),
+  parentID = "root",
+  validations
+}) {
   const requiredFields = new Set(accRequired);
   Object.keys(node.properties ?? []).forEach((fieldName) => {
     const field = getField(fieldName, formFields);
-    updateField(field, requiredFields, node, formValues);
+    updateField(field, requiredFields, node, formValues, validations, { parentID });
   });
   node.required?.forEach((fieldName) => {
     requiredFields.add(fieldName);
-    updateField(getField(fieldName, formFields), requiredFields, node, formValues);
+    updateField(getField(fieldName, formFields), requiredFields, node, formValues, validations, {
+      parentID
+    });
   });
   if (node.if) {
-    const matchesCondition = checkIfConditionMatches(node, formValues, formFields);
+    const matchesCondition = checkIfConditionMatches(node, formValues, formFields, validations);
     if (matchesCondition && node.then) {
-      const { required: branchRequired } = processNode(
-        node.then,
+      const { required: branchRequired } = processNode({
+        node: node.then,
         formValues,
         formFields,
-        requiredFields
-      );
+        accRequired: requiredFields,
+        parentID,
+        validations
+      });
       branchRequired.forEach((field) => requiredFields.add(field));
     } else if (node.else) {
-      const { required: branchRequired } = processNode(
-        node.else,
+      const { required: branchRequired } = processNode({
+        node: node.else,
         formValues,
         formFields,
-        requiredFields
-      );
+        accRequired: requiredFields,
+        parentID,
+        validations
+      });
       branchRequired.forEach((field) => requiredFields.add(field));
     }
   }
@@ -815,12 +1182,21 @@ function processNode(node, formValues, formFields, accRequired = /* @__PURE__ */
     node.anyOf.forEach(({ required = [] }) => {
       required.forEach((fieldName) => {
         const field = getField(fieldName, formFields);
-        updateField(field, requiredFields, node, formValues);
+        updateField(field, requiredFields, node, formValues, validations, { parentID });
       });
     });
   }
   if (node.allOf) {
-    node.allOf.map((allOfNode) => processNode(allOfNode, formValues, formFields, requiredFields)).forEach(({ required: allOfItemRequired }) => {
+    node.allOf.map(
+      (allOfNode) => processNode({
+        node: allOfNode,
+        formValues,
+        formFields,
+        accRequired: requiredFields,
+        parentID,
+        validations
+      })
+    ).forEach(({ required: allOfItemRequired }) => {
       allOfItemRequired.forEach(requiredFields.add, requiredFields);
     });
   }
@@ -828,10 +1204,27 @@ function processNode(node, formValues, formFields, accRequired = /* @__PURE__ */
     Object.entries(node.properties).forEach(([name, nestedNode]) => {
       const inputType = getInputType(nestedNode);
       if (inputType === supportedTypes.FIELDSET) {
-        processNode(nestedNode, formValues[name] || {}, getField(name, formFields).fields);
+        processNode({
+          node: nestedNode,
+          formValues: formValues[name] || {},
+          formFields: getField(name, formFields).fields,
+          validations,
+          parentID: name
+        });
       }
     });
   }
+  if (node["x-jsf-logic"]) {
+    const { required: requiredFromLogic } = processJSONLogicNode({
+      node: node["x-jsf-logic"],
+      formValues,
+      formFields,
+      accRequired: requiredFields,
+      parentID,
+      validations
+    });
+    requiredFromLogic.forEach((field) => requiredFields.add(field));
+  }
   return {
     required: requiredFields
   };
@@ -846,11 +1239,11 @@ function clearValuesIfNotVisible(fields, formValues) {
     }
   });
 }
-function updateFieldsProperties(fields, formValues, jsonSchema) {
+function updateFieldsProperties(fields, formValues, jsonSchema, validations) {
   if (!jsonSchema?.properties) {
     return;
   }
-  processNode(jsonSchema, formValues, fields);
+  processNode({ node: jsonSchema, formValues, formFields: fields, validations });
   clearValuesIfNotVisible(fields, formValues);
 }
 var notNullOption = (opt) => opt.const !== null;
@@ -893,11 +1286,20 @@ function extractParametersFromNode(schemaNode) {
   }
   const presentation = pickXKey(schemaNode, "presentation") ?? {};
   const errorMessage = pickXKey(schemaNode, "errorMessage") ?? {};
+  const requiredValidations = schemaNode["x-jsf-logic-validations"];
+  const computedAttributes = schemaNode["x-jsf-logic-computedAttrs"];
+  const decoratedComputedAttributes = {
+    ...computedAttributes ?? {},
+    ...computedAttributes?.const && computedAttributes?.default ? { value: computedAttributes.const } : {}
+  };
   const node = omit(schemaNode, ["x-jsf-presentation", "presentation"]);
   const description = presentation?.description || node.description;
   const statementDescription = containsHTML(presentation.statement?.description) ? wrapWithSpan(presentation.statement.description, { class: "jsf-statement" }) : presentation.statement?.description;
   return omitBy(
     {
+      const: node.const,
+      // This is a "forced value" when both const and default are present.
+      ...node.const && node.default ? { value: node.const } : {},
       label: node.title,
       readOnly: node.readOnly,
       ...node.deprecated && {
@@ -932,6 +1334,8 @@ function extractParametersFromNode(schemaNode) {
       },
       // Handle [name].presentation
       ...presentation,
+      requiredValidations,
+      computedAttributes: decoratedComputedAttributes,
       description: containsHTML(description) ? wrapWithSpan(description, {
         class: "jsf-description"
       }) : description,
@@ -968,9 +1372,9 @@ function yupToFormErrors(yupError) {
   }
   return errors;
 }
-var handleValuesChange = (fields, jsonSchema, config) => (values) => {
-  updateFieldsProperties(fields, values, jsonSchema);
-  const lazySchema = lazy(() => buildCompleteYupSchema(fields, config));
+var handleValuesChange = (fields, jsonSchema, config, validations) => (values) => {
+  updateFieldsProperties(fields, values, jsonSchema, validations);
+  const lazySchema = lazy(() => buildCompleteYupSchema(fields, config, validations));
   let errors;
   try {
     lazySchema.validateSync(values, {
@@ -1024,8 +1428,8 @@ function rebuildFieldset(fields, property) {
     required: isFieldRequired(property, field)
   }));
 }
-function calculateConditionalProperties(fieldParams, customProperties) {
-  return (isRequired, conditionBranch) => {
+function calculateConditionalProperties(fieldParams, customProperties, validations, config) {
+  return (isRequired, conditionBranch, __, _, formValues) => {
     const conditionalProperty = conditionBranch?.properties?.[fieldParams.name];
     if (conditionalProperty) {
       const presentation = pickXKey(conditionalProperty, "presentation") ?? {};
@@ -1039,17 +1443,31 @@ function calculateConditionalProperties(fieldParams, customProperties) {
         fieldSetFields = rebuildFieldset(fieldParams.fields, conditionalProperty);
         newFieldParams.fields = fieldSetFields;
       }
+      const { computedAttributes, ...restNewFieldParams } = newFieldParams;
+      const calculatedComputedAttributes = computedAttributes ? calculateComputedAttributes(newFieldParams, config)({ validations, formValues }) : {};
+      const requiredValidations = [
+        ...fieldParams.requiredValidations ?? [],
+        ...restNewFieldParams.requiredValidations ?? []
+      ];
       const base = {
         isVisible: true,
         required: isRequired,
         ...presentation?.inputType && { type: presentation.inputType },
-        schema: buildYupSchema({
-          ...fieldParams,
-          ...newFieldParams,
-          // If there are inner fields (case of fieldset) they need to be updated based on the condition
-          fields: fieldSetFields,
-          required: isRequired
-        })
+        ...calculatedComputedAttributes,
+        ...calculatedComputedAttributes.value ? { value: calculatedComputedAttributes.value } : { value: void 0 },
+        schema: buildYupSchema(
+          {
+            ...fieldParams,
+            ...restNewFieldParams,
+            ...calculatedComputedAttributes,
+            requiredValidations,
+            // If there are inner fields (case of fieldset) they need to be updated based on the condition
+            fields: fieldSetFields,
+            required: isRequired
+          },
+          config,
+          validations
+        )
       };
       return omit2(merge2(base, presentation, newFieldParams), ["inputType"]);
     }
@@ -1143,14 +1561,19 @@ function sortByOrderOrPosition(a, b, order) {
 function removeInvalidAttributes(fields) {
   return omit3(fields, ["items", "maxFileSize", "isDynamic"]);
 }
-function buildFieldParameters(name, fieldProperties, required = [], config = {}) {
+function buildFieldParameters(name, fieldProperties, required = [], config = {}, validations) {
   const { position } = pickXKey(fieldProperties, "presentation") ?? {};
   let fields;
   const inputType = getInputType(fieldProperties, config.strictInputType, name);
   if (inputType === supportedTypes.FIELDSET) {
-    fields = getFieldsFromJSONSchema(fieldProperties, {
-      customProperties: get3(config, `customProperties.${name}`, {})
-    });
+    fields = getFieldsFromJSONSchema(
+      fieldProperties,
+      {
+        customProperties: get3(config, `customProperties.${name}`, {}),
+        parentID: name
+      },
+      validations
+    );
   }
   const result = {
     name,
@@ -1165,9 +1588,9 @@ function buildFieldParameters(name, fieldProperties, required = [], config = {})
   };
   return omitBy2(result, isNil3);
 }
-function convertJSONSchemaPropertiesToFieldParameters({ properties, required, "x-jsf-order": order }, config = {}) {
+function convertJSONSchemaPropertiesToFieldParameters({ properties, required, "x-jsf-order": order }, config = {}, validations) {
   const sortFields = (a, b) => sortByOrderOrPosition(a, b, order);
-  return Object.entries(properties).filter(([, value]) => typeof value === "object").map(([key, value]) => buildFieldParameters(key, value, required, config)).sort(sortFields).map(({ position, ...fieldParams }) => fieldParams);
+  return Object.entries(properties).filter(([, value]) => typeof value === "object").map(([key, value]) => buildFieldParameters(key, value, required, config, validations)).sort(sortFields).map(({ position, ...fieldParams }) => fieldParams);
 }
 function applyFieldsDependencies(fieldsParameters, node) {
   if (node?.then) {
@@ -1189,6 +1612,9 @@ function applyFieldsDependencies(fieldsParameters, node) {
       applyFieldsDependencies(fieldsParameters, condition);
     });
   }
+  if (node?.["x-jsf-logic"]) {
+    applyFieldsDependencies(fieldsParameters, node["x-jsf-logic"]);
+  }
 }
 function getCustomPropertiesForField(fieldParams, config) {
   return config?.customProperties?.[fieldParams.name];
@@ -1200,15 +1626,16 @@ function getComposeFunctionForField(fieldParams, hasCustomizations) {
   }
   return composeFn;
 }
-function buildField(fieldParams, config, scopedJsonSchema) {
+function buildField(fieldParams, config, scopedJsonSchema, validations) {
   const customProperties = getCustomPropertiesForField(fieldParams, config);
   const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
-  const yupSchema = buildYupSchema(fieldParams, config);
-  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties);
+  const yupSchema = buildYupSchema(fieldParams, config, validations);
+  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties, validations, config);
   const calculateCustomValidationPropertiesClosure = calculateCustomValidationProperties(
     fieldParams,
     customProperties
   );
+  const getComputedAttributes = Object.keys(fieldParams.computedAttributes).length > 0 && calculateComputedAttributes(fieldParams, config);
   const hasCustomValidations = !!customProperties && size(pick2(customProperties, SUPPORTED_CUSTOM_VALIDATION_FIELD_PARAMS)) > 0;
   const finalFieldParams = {
     // invalid attribute cleanup
@@ -1221,6 +1648,7 @@ function buildField(fieldParams, config, scopedJsonSchema) {
     ...hasCustomValidations && {
       calculateCustomValidationProperties: calculateCustomValidationPropertiesClosure
     },
+    ...getComputedAttributes && { getComputedAttributes },
     // field customization properties
     ...customProperties && { fieldCustomization: customProperties },
     // base schema
@@ -1229,11 +1657,15 @@ function buildField(fieldParams, config, scopedJsonSchema) {
   };
   return composeFn(finalFieldParams);
 }
-function getFieldsFromJSONSchema(scopedJsonSchema, config) {
+function getFieldsFromJSONSchema(scopedJsonSchema, config, validations) {
   if (!scopedJsonSchema) {
     return [];
   }
-  const fieldParamsList = convertJSONSchemaPropertiesToFieldParameters(scopedJsonSchema, config);
+  const fieldParamsList = convertJSONSchemaPropertiesToFieldParameters(
+    scopedJsonSchema,
+    config,
+    validations
+  );
   applyFieldsDependencies(fieldParamsList, scopedJsonSchema);
   const fields = [];
   fieldParamsList.forEach((fieldParams) => {
@@ -1253,11 +1685,11 @@ function getFieldsFromJSONSchema(scopedJsonSchema, config) {
         fields: () => groupArrayFields,
         addFieldText: fieldParams.addFieldText
       };
-      buildField(fieldParams, config, scopedJsonSchema).forEach((groupField) => {
+      buildField(fieldParams, config, scopedJsonSchema, validations).forEach((groupField) => {
         fields.push(groupField);
       });
     } else {
-      fields.push(buildField(fieldParams, config, scopedJsonSchema));
+      fields.push(buildField(fieldParams, config, scopedJsonSchema, validations));
     }
   });
   return fields;
@@ -1268,9 +1700,15 @@ function createHeadlessForm(jsonSchema, customConfig = {}) {
     ...customConfig
   };
   try {
-    const fields = getFieldsFromJSONSchema(jsonSchema, config);
-    const handleValidation = handleValuesChange(fields, jsonSchema, config);
-    updateFieldsProperties(fields, getPrefillValues(fields, config.initialValues), jsonSchema);
+    const validations = createValidationChecker(jsonSchema);
+    const fields = getFieldsFromJSONSchema(jsonSchema, config, validations);
+    const handleValidation = handleValuesChange(fields, jsonSchema, config, validations);
+    updateFieldsProperties(
+      fields,
+      getPrefillValues(fields, config.initialValues),
+      jsonSchema,
+      validations
+    );
     return {
       fields,
       handleValidation,