@remoteoss/json-schema-form 0.4.5-beta.0 → 0.5.0-beta.0

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.4.5-beta.0
- Generated: Thu, 31 Aug 2023 07:23:05 GMT
+ NPM Package: @remoteoss/json-schema-form@0.5.0-beta.0
+ Generated: Tue, 12 Sep 2023 07:51:25 GMT
 
  MIT License
 
@@ -6421,6 +6421,384 @@ var require_randexp = __commonJS({
   }
 });
 
+// node_modules/json-logic-js/logic.js
+var require_logic = __commonJS({
+  "node_modules/json-logic-js/logic.js"(exports2, module2) {
+    (function(root2, factory) {
+      if (typeof define === "function" && define.amd) {
+        define(factory);
+      } else if (typeof exports2 === "object") {
+        module2.exports = factory();
+      } else {
+        root2.jsonLogic = factory();
+      }
+    })(exports2, function() {
+      "use strict";
+      if (!Array.isArray) {
+        Array.isArray = function(arg) {
+          return Object.prototype.toString.call(arg) === "[object Array]";
+        };
+      }
+      function arrayUnique(array2) {
+        var a = [];
+        for (var i = 0, l = array2.length; i < l; i++) {
+          if (a.indexOf(array2[i]) === -1) {
+            a.push(array2[i]);
+          }
+        }
+        return a;
+      }
+      var jsonLogic2 = {};
+      var operations = {
+        "==": function(a, b) {
+          return a == b;
+        },
+        "===": function(a, b) {
+          return a === b;
+        },
+        "!=": function(a, b) {
+          return a != b;
+        },
+        "!==": function(a, b) {
+          return a !== b;
+        },
+        ">": function(a, b) {
+          return a > b;
+        },
+        ">=": function(a, b) {
+          return a >= b;
+        },
+        "<": function(a, b, c) {
+          return c === void 0 ? a < b : a < b && b < c;
+        },
+        "<=": function(a, b, c) {
+          return c === void 0 ? a <= b : a <= b && b <= c;
+        },
+        "!!": function(a) {
+          return jsonLogic2.truthy(a);
+        },
+        "!": function(a) {
+          return !jsonLogic2.truthy(a);
+        },
+        "%": function(a, b) {
+          return a % b;
+        },
+        "log": function(a) {
+          console.log(a);
+          return a;
+        },
+        "in": function(a, b) {
+          if (!b || typeof b.indexOf === "undefined")
+            return false;
+          return b.indexOf(a) !== -1;
+        },
+        "cat": function() {
+          return Array.prototype.join.call(arguments, "");
+        },
+        "substr": function(source, start, end) {
+          if (end < 0) {
+            var temp = String(source).substr(start);
+            return temp.substr(0, temp.length + end);
+          }
+          return String(source).substr(start, end);
+        },
+        "+": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return parseFloat(a, 10) + parseFloat(b, 10);
+          }, 0);
+        },
+        "*": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return parseFloat(a, 10) * parseFloat(b, 10);
+          });
+        },
+        "-": function(a, b) {
+          if (b === void 0) {
+            return -a;
+          } else {
+            return a - b;
+          }
+        },
+        "/": function(a, b) {
+          return a / b;
+        },
+        "min": function() {
+          return Math.min.apply(this, arguments);
+        },
+        "max": function() {
+          return Math.max.apply(this, arguments);
+        },
+        "merge": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return a.concat(b);
+          }, []);
+        },
+        "var": function(a, b) {
+          var not_found = b === void 0 ? null : b;
+          var data = this;
+          if (typeof a === "undefined" || a === "" || a === null) {
+            return data;
+          }
+          var sub_props = String(a).split(".");
+          for (var i = 0; i < sub_props.length; i++) {
+            if (data === null || data === void 0) {
+              return not_found;
+            }
+            data = data[sub_props[i]];
+            if (data === void 0) {
+              return not_found;
+            }
+          }
+          return data;
+        },
+        "missing": function() {
+          var missing = [];
+          var keys2 = Array.isArray(arguments[0]) ? arguments[0] : arguments;
+          for (var i = 0; i < keys2.length; i++) {
+            var key = keys2[i];
+            var value = jsonLogic2.apply({ "var": key }, this);
+            if (value === null || value === "") {
+              missing.push(key);
+            }
+          }
+          return missing;
+        },
+        "missing_some": function(need_count, options) {
+          var are_missing = jsonLogic2.apply({ "missing": options }, this);
+          if (options.length - are_missing.length >= need_count) {
+            return [];
+          } else {
+            return are_missing;
+          }
+        }
+      };
+      jsonLogic2.is_logic = function(logic) {
+        return typeof logic === "object" && // An object
+        logic !== null && // but not null
+        !Array.isArray(logic) && // and not an array
+        Object.keys(logic).length === 1;
+      };
+      jsonLogic2.truthy = function(value) {
+        if (Array.isArray(value) && value.length === 0) {
+          return false;
+        }
+        return !!value;
+      };
+      jsonLogic2.get_operator = function(logic) {
+        return Object.keys(logic)[0];
+      };
+      jsonLogic2.get_values = function(logic) {
+        return logic[jsonLogic2.get_operator(logic)];
+      };
+      jsonLogic2.apply = function(logic, data) {
+        if (Array.isArray(logic)) {
+          return logic.map(function(l) {
+            return jsonLogic2.apply(l, data);
+          });
+        }
+        if (!jsonLogic2.is_logic(logic)) {
+          return logic;
+        }
+        var op = jsonLogic2.get_operator(logic);
+        var values2 = logic[op];
+        var i;
+        var current;
+        var scopedLogic;
+        var scopedData;
+        var initial;
+        if (!Array.isArray(values2)) {
+          values2 = [values2];
+        }
+        if (op === "if" || op == "?:") {
+          for (i = 0; i < values2.length - 1; i += 2) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(values2[i], data))) {
+              return jsonLogic2.apply(values2[i + 1], data);
+            }
+          }
+          if (values2.length === i + 1) {
+            return jsonLogic2.apply(values2[i], data);
+          }
+          return null;
+        } else if (op === "and") {
+          for (i = 0; i < values2.length; i += 1) {
+            current = jsonLogic2.apply(values2[i], data);
+            if (!jsonLogic2.truthy(current)) {
+              return current;
+            }
+          }
+          return current;
+        } else if (op === "or") {
+          for (i = 0; i < values2.length; i += 1) {
+            current = jsonLogic2.apply(values2[i], data);
+            if (jsonLogic2.truthy(current)) {
+              return current;
+            }
+          }
+          return current;
+        } else if (op === "filter") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData)) {
+            return [];
+          }
+          return scopedData.filter(function(datum) {
+            return jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, datum));
+          });
+        } else if (op === "map") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData)) {
+            return [];
+          }
+          return scopedData.map(function(datum) {
+            return jsonLogic2.apply(scopedLogic, datum);
+          });
+        } else if (op === "reduce") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          initial = typeof values2[2] !== "undefined" ? values2[2] : null;
+          if (!Array.isArray(scopedData)) {
+            return initial;
+          }
+          return scopedData.reduce(
+            function(accumulator, current2) {
+              return jsonLogic2.apply(
+                scopedLogic,
+                { current: current2, accumulator }
+              );
+            },
+            initial
+          );
+        } else if (op === "all") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return false;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (!jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return false;
+            }
+          }
+          return true;
+        } else if (op === "none") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return true;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return false;
+            }
+          }
+          return true;
+        } else if (op === "some") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return false;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return true;
+            }
+          }
+          return false;
+        }
+        values2 = values2.map(function(val) {
+          return jsonLogic2.apply(val, data);
+        });
+        if (operations.hasOwnProperty(op) && typeof operations[op] === "function") {
+          return operations[op].apply(data, values2);
+        } else if (op.indexOf(".") > 0) {
+          var sub_ops = String(op).split(".");
+          var operation = operations;
+          for (i = 0; i < sub_ops.length; i++) {
+            if (!operation.hasOwnProperty(sub_ops[i])) {
+              throw new Error("Unrecognized operation " + op + " (failed at " + sub_ops.slice(0, i + 1).join(".") + ")");
+            }
+            operation = operation[sub_ops[i]];
+          }
+          return operation.apply(data, values2);
+        }
+        throw new Error("Unrecognized operation " + op);
+      };
+      jsonLogic2.uses_data = function(logic) {
+        var collection = [];
+        if (jsonLogic2.is_logic(logic)) {
+          var op = jsonLogic2.get_operator(logic);
+          var values2 = logic[op];
+          if (!Array.isArray(values2)) {
+            values2 = [values2];
+          }
+          if (op === "var") {
+            collection.push(values2[0]);
+          } else {
+            values2.forEach(function(val) {
+              collection.push.apply(collection, jsonLogic2.uses_data(val));
+            });
+          }
+        }
+        return arrayUnique(collection);
+      };
+      jsonLogic2.add_operation = function(name, code) {
+        operations[name] = code;
+      };
+      jsonLogic2.rm_operation = function(name) {
+        delete operations[name];
+      };
+      jsonLogic2.rule_like = function(rule, pattern) {
+        if (pattern === rule) {
+          return true;
+        }
+        if (pattern === "@") {
+          return true;
+        }
+        if (pattern === "number") {
+          return typeof rule === "number";
+        }
+        if (pattern === "string") {
+          return typeof rule === "string";
+        }
+        if (pattern === "array") {
+          return Array.isArray(rule) && !jsonLogic2.is_logic(rule);
+        }
+        if (jsonLogic2.is_logic(pattern)) {
+          if (jsonLogic2.is_logic(rule)) {
+            var pattern_op = jsonLogic2.get_operator(pattern);
+            var rule_op = jsonLogic2.get_operator(rule);
+            if (pattern_op === "@" || pattern_op === rule_op) {
+              return jsonLogic2.rule_like(
+                jsonLogic2.get_values(rule, false),
+                jsonLogic2.get_values(pattern, false)
+              );
+            }
+          }
+          return false;
+        }
+        if (Array.isArray(pattern)) {
+          if (Array.isArray(rule)) {
+            if (pattern.length !== rule.length) {
+              return false;
+            }
+            for (var i = 0; i < pattern.length; i += 1) {
+              if (!jsonLogic2.rule_like(rule[i], pattern[i])) {
+                return false;
+              }
+            }
+            return true;
+          } else {
+            return false;
+          }
+        }
+        return false;
+      };
+      return jsonLogic2;
+    });
+  }
+});
+
 // node_modules/lodash/_baseInRange.js
 var require_baseInRange = __commonJS({
   "node_modules/lodash/_baseInRange.js"(exports2, module2) {
@@ -11351,6 +11729,103 @@ function _composeFieldCustomClosure(defaultComposeFn) {
 var import_flow = __toESM(require_flow());
 var import_noop = __toESM(require_noop());
 var import_randexp = __toESM(require_randexp());
+
+// src/jsonLogic.js
+var import_json_logic_js = __toESM(require_logic());
+function createValidationChecker(schema) {
+  const scopes = /* @__PURE__ */ new Map();
+  function createScopes(jsonSchema, key = "root") {
+    scopes.set(key, createValidationsScope(jsonSchema));
+    Object.entries(jsonSchema?.properties ?? {}).filter(([, property2]) => property2.type === "object" || property2.type === "array").forEach(([key2, property2]) => {
+      if (property2.type === "array") {
+        createScopes(property2.items, `${key2}[]`);
+      } else {
+        createScopes(property2, key2);
+      }
+    });
+  }
+  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 ?? {});
+  validations.forEach(([id, validation]) => {
+    validationMap.set(id, validation);
+  });
+  computedValues.forEach(([id, computedValue]) => {
+    computedValuesMap.set(id, computedValue);
+  });
+  function validate2(rule, values2) {
+    return import_json_logic_js.default.apply(rule, replaceUndefinedValuesWithNulls(values2));
+  }
+  return {
+    validationMap,
+    computedValuesMap,
+    validate: validate2,
+    applyValidationRuleInCondition(id, values2) {
+      const validation = validationMap.get(id);
+      return validate2(validation.rule, values2);
+    },
+    applyComputedValueInField(id, values2) {
+      const validation = computedValuesMap.get(id);
+      return validate2(validation.rule, values2);
+    },
+    applyComputedValueRuleInCondition(id, values2) {
+      const validation = computedValuesMap.get(id);
+      return validate2(validation.rule, values2);
+    }
+  };
+}
+function replaceUndefinedValuesWithNulls(values2 = {}) {
+  return Object.entries(values2).reduce((prev, [key, value]) => {
+    return { ...prev, [key]: value === void 0 ? null : value };
+  }, {});
+}
+function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
+  const { parentID = "root" } = config;
+  const validation = logic.getScope(parentID).validationMap.get(id);
+  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 import_json_logic_js.default.apply(validation.rule, parent);
+    }
+  );
+}
+function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
+  return ({ logic, formValues }) => {
+    const { computedAttributes } = fieldParams;
+    const attributes = Object.fromEntries(
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID)).filter(([, value]) => value !== null)
+    );
+    return attributes;
+  };
+}
+function handleComputedAttribute(logic, formValues, parentID) {
+  return ([key, value]) => {
+    if (key === "const")
+      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
+    if (typeof value === "string") {
+      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
+    }
+  };
+}
+
+// src/yupSchema.js
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
 var baseString = StringSchema().trim();
 var todayDateHint = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
@@ -11473,7 +11948,7 @@ var getYupSchema = ({ inputType, ...field }) => {
   }
   return yupSchemas[inputType] || yupSchemasToJsonTypes[jsonType];
 };
-function buildYupSchema(field, config) {
+function buildYupSchema(field, config, logic) {
   const { inputType, jsonType: jsonTypeValue, errorMessage = {}, ...propertyFields } = field;
   const isCheckboxBoolean = typeof propertyFields.checkboxValue === "boolean";
   let baseSchema;
@@ -11623,6 +12098,11 @@ function buildYupSchema(field, config) {
   if (propertyFields.const) {
     validators.push(withConst);
   }
+  if (propertyFields.requiredValidations) {
+    propertyFields.requiredValidations.forEach(
+      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, logic, config }))
+    );
+  }
   return (0, import_flow.default)(validators);
 }
 function getNoSortEdges(fields = []) {
@@ -11662,8 +12142,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, logic) {
+  const validator = buildYupSchema(field, {}, logic);
   return validator().isValidSync(value);
 }
 function compareFormValueWithSchemaValue(formValue, schemaValue) {
@@ -11737,7 +12217,7 @@ function getPrefillValues(fields, initialValues = {}) {
   });
   return initialValues;
 }
-function updateField(field, requiredFields, node, formValues) {
+function updateField(field, requiredFields, node, formValues, logic, config) {
   if (!field) {
     return;
   }
@@ -11759,6 +12239,17 @@ function updateField(field, requiredFields, node, formValues) {
       }
     }
   });
+  if (field.getComputedAttributes) {
+    const computedFieldValues = field.getComputedAttributes({
+      field,
+      isRequired: fieldIsRequired,
+      node,
+      formValues,
+      config,
+      logic
+    });
+    updateValues(computedFieldValues);
+  }
   if (field.calculateConditionalProperties) {
     const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
     updateValues(newFieldValues);
@@ -11772,33 +12263,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",
+  logic
+}) {
   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, logic, { parentID });
   });
   node.required?.forEach((fieldName) => {
     requiredFields.add(fieldName);
-    updateField(getField(fieldName, formFields), requiredFields, node, formValues);
+    updateField(getField(fieldName, formFields), requiredFields, node, formValues, logic, {
+      parentID
+    });
   });
   if (node.if) {
-    const matchesCondition = checkIfConditionMatches(node, formValues, formFields);
+    const matchesCondition = checkIfConditionMatches(node, formValues, formFields, logic);
     if (matchesCondition && node.then) {
-      const { required: branchRequired } = processNode(
-        node.then,
+      const { required: branchRequired } = processNode({
+        node: node.then,
         formValues,
         formFields,
-        requiredFields
-      );
+        accRequired: requiredFields,
+        parentID,
+        logic
+      });
       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,
+        logic
+      });
       branchRequired.forEach((field) => requiredFields.add(field));
     }
   }
@@ -11810,12 +12314,21 @@ function processNode(node, formValues, formFields, accRequired = /* @__PURE__ */
     node.anyOf.forEach(({ required: required2 = [] }) => {
       required2.forEach((fieldName) => {
         const field = getField(fieldName, formFields);
-        updateField(field, requiredFields, node, formValues);
+        updateField(field, requiredFields, node, formValues, logic, { 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,
+        logic
+      })
+    ).forEach(({ required: allOfItemRequired }) => {
       allOfItemRequired.forEach(requiredFields.add, requiredFields);
     });
   }
@@ -11823,7 +12336,13 @@ 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,
+          parentID: name,
+          logic
+        });
       }
     });
   }
@@ -11841,11 +12360,11 @@ function clearValuesIfNotVisible(fields, formValues) {
     }
   });
 }
-function updateFieldsProperties(fields, formValues, jsonSchema) {
+function updateFieldsProperties(fields, formValues, jsonSchema, logic) {
   if (!jsonSchema?.properties) {
     return;
   }
-  processNode(jsonSchema, formValues, fields);
+  processNode({ node: jsonSchema, formValues, formFields: fields, logic });
   clearValuesIfNotVisible(fields, formValues);
 }
 var notNullOption = (opt) => opt.const !== null;
@@ -11888,12 +12407,16 @@ 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 = getDecoratedComputedAttributes(computedAttributes);
   const node = (0, import_omit.default)(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 (0, import_omitBy.default)(
     {
       const: node.const,
+      ...node.const && node.default ? { value: node.const } : {},
       label: node.title,
       readOnly: node.readOnly,
       ...node.deprecated && {
@@ -11928,6 +12451,8 @@ function extractParametersFromNode(schemaNode) {
       },
       // Handle [name].presentation
       ...presentation,
+      requiredValidations,
+      computedAttributes: decoratedComputedAttributes,
       description: containsHTML(description) ? wrapWithSpan(description, {
         class: "jsf-description"
       }) : description,
@@ -11964,8 +12489,8 @@ function yupToFormErrors(yupError) {
   }
   return errors;
 }
-var handleValuesChange = (fields, jsonSchema, config) => (values2) => {
-  updateFieldsProperties(fields, values2, jsonSchema);
+var handleValuesChange = (fields, jsonSchema, config, logic) => (values2) => {
+  updateFieldsProperties(fields, values2, jsonSchema, logic);
   const lazySchema = lazy(() => buildCompleteYupSchema(fields, config));
   let errors;
   try {
@@ -11984,6 +12509,12 @@ var handleValuesChange = (fields, jsonSchema, config) => (values2) => {
     formErrors: yupToFormErrors(errors)
   };
 };
+function getDecoratedComputedAttributes(computedAttributes) {
+  return {
+    ...computedAttributes ?? {},
+    ...computedAttributes?.const && computedAttributes?.default ? { value: computedAttributes.const } : {}
+  };
+}
 
 // src/calculateConditionalProperties.js
 function isFieldRequired(node, field) {
@@ -12185,6 +12716,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];
@@ -12196,15 +12730,16 @@ function getComposeFunctionForField(fieldParams, hasCustomizations) {
   }
   return composeFn;
 }
-function buildField(fieldParams, config, scopedJsonSchema) {
+function buildField(fieldParams, config, scopedJsonSchema, logic) {
   const customProperties = getCustomPropertiesForField(fieldParams, config);
   const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
-  const yupSchema = buildYupSchema(fieldParams, config);
+  const yupSchema = buildYupSchema(fieldParams, config, logic);
   const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties);
   const calculateCustomValidationPropertiesClosure = calculateCustomValidationProperties(
     fieldParams,
     customProperties
   );
+  const getComputedAttributes = Object.keys(fieldParams.computedAttributes).length > 0 && calculateComputedAttributes(fieldParams, config);
   const hasCustomValidations = !!customProperties && (0, import_size.default)((0, import_pick2.default)(customProperties, SUPPORTED_CUSTOM_VALIDATION_FIELD_PARAMS)) > 0;
   const finalFieldParams = {
     // invalid attribute cleanup
@@ -12217,6 +12752,7 @@ function buildField(fieldParams, config, scopedJsonSchema) {
     ...hasCustomValidations && {
       calculateCustomValidationProperties: calculateCustomValidationPropertiesClosure
     },
+    ...getComputedAttributes && { getComputedAttributes },
     // field customization properties
     ...customProperties && { fieldCustomization: customProperties },
     // base schema
@@ -12225,7 +12761,7 @@ function buildField(fieldParams, config, scopedJsonSchema) {
   };
   return composeFn(finalFieldParams);
 }
-function getFieldsFromJSONSchema(scopedJsonSchema, config) {
+function getFieldsFromJSONSchema(scopedJsonSchema, config, logic) {
   if (!scopedJsonSchema) {
     return [];
   }
@@ -12249,11 +12785,11 @@ function getFieldsFromJSONSchema(scopedJsonSchema, config) {
         fields: () => groupArrayFields,
         addFieldText: fieldParams.addFieldText
       };
-      buildField(fieldParams, config, scopedJsonSchema).forEach((groupField) => {
+      buildField(fieldParams, config, scopedJsonSchema, logic).forEach((groupField) => {
         fields.push(groupField);
       });
     } else {
-      fields.push(buildField(fieldParams, config, scopedJsonSchema));
+      fields.push(buildField(fieldParams, config, scopedJsonSchema, logic));
     }
   });
   return fields;
@@ -12264,9 +12800,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 logic = createValidationChecker(jsonSchema);
+    const fields = getFieldsFromJSONSchema(jsonSchema, config, logic);
+    const handleValidation = handleValuesChange(fields, jsonSchema, config, logic);
+    updateFieldsProperties(
+      fields,
+      getPrefillValues(fields, config.initialValues),
+      jsonSchema,
+      logic
+    );
     return {
       fields,
       handleValidation,