@remoteoss/json-schema-form 0.4.4-dev.20230829101351 → 0.4.4-dev.20230829191632

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.4.4-dev.20230829101351
- Generated: Tue, 29 Aug 2023 10:14:13 GMT
+ NPM Package: @remoteoss/json-schema-form@0.4.4-dev.20230829191632
+ Generated: Tue, 29 Aug 2023 19:17:06 GMT
 
  MIT License
 
@@ -5648,384 +5648,6 @@ var require_isEmpty = __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/_createFlow.js
 var require_createFlow = __commonJS({
   "node_modules/lodash/_createFlow.js"(exports2, module2) {
@@ -11422,8 +11044,8 @@ function hasProperty(object2, propertyName) {
 }
 
 // src/checkIfConditionMatches.js
-function checkIfConditionMatches(node, formValues, formFields, validations) {
-  return Object.keys(node.if.properties ?? {}).every((name) => {
+function checkIfConditionMatches(node, formValues, formFields) {
+  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".
@@ -11449,8 +11071,7 @@ function checkIfConditionMatches(node, formValues, formFields, validations) {
       return checkIfConditionMatches(
         { if: currentProperty },
         formValues[name],
-        getField(name, formFields).fields,
-        validations
+        getField(name, formFields).fields
       );
     }
     const field = getField(name, formFields);
@@ -11466,23 +11087,6 @@ function checkIfConditionMatches(node, formValues, formFields, validations) {
     );
   });
 }
-function checkIfMatchesValidationsAndComputedValues(node, formValues, validations, parentID) {
-  const validationsMatch = Object.entries(node.if.validations ?? {}).every(([name, property2]) => {
-    const currentValue = validations.getScope(parentID).evaluateValidationRuleInCondition(name, formValues);
-    if (Object.hasOwn(property2, "const") && currentValue === property2.const)
-      return true;
-    return false;
-  });
-  const computedValuesMatch = Object.entries(node.if.computedValues ?? {}).every(
-    ([name, property2]) => {
-      const currentValue = validations.getScope(parentID).evaluateComputedValueRuleInCondition(name, formValues);
-      if (Object.hasOwn(property2, "const") && currentValue === property2.const)
-        return true;
-      return false;
-    }
-  );
-  return computedValuesMatch && validationsMatch;
-}
 
 // src/internals/helpers.js
 var import_merge = __toESM(require_merge2());
@@ -11743,9 +11347,6 @@ function _composeFieldCustomClosure(defaultComposeFn) {
   };
 }
 
-// src/jsonLogic.js
-var import_json_logic_js = __toESM(require_logic());
-
 // src/yupSchema.js
 var import_flow = __toESM(require_flow());
 var import_noop = __toESM(require_noop());
@@ -11872,7 +11473,7 @@ var getYupSchema = ({ inputType, ...field }) => {
   }
   return yupSchemas[inputType] || yupSchemasToJsonTypes[jsonType];
 };
-function buildYupSchema(field, config, validations) {
+function buildYupSchema(field, config) {
   const { inputType, jsonType: jsonTypeValue, errorMessage = {}, ...propertyFields } = field;
   const isCheckboxBoolean = typeof propertyFields.checkboxValue === "boolean";
   let baseSchema;
@@ -11972,8 +11573,7 @@ function buildYupSchema(field, config, validations) {
             ...fieldSetfield,
             inputType: fieldSetfield.type
           },
-          { ...config, parentID: field.name },
-          validations
+          config
         )();
       }
     });
@@ -11984,11 +11584,7 @@ function buildYupSchema(field, config, validations) {
       propertyFields.nthFieldGroup.fields().reduce(
         (schema, groupArrayField) => ({
           ...schema,
-          [groupArrayField.name]: buildYupSchema(
-            groupArrayField,
-            { ...config, parentID: `${propertyFields.nthFieldGroup.name}[]` },
-            validations
-          )()
+          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
         }),
         {}
       )
@@ -12027,11 +11623,6 @@ function buildYupSchema(field, config, validations) {
   if (propertyFields.const) {
     validators.push(withConst);
   }
-  if (propertyFields.requiredValidations) {
-    propertyFields.requiredValidations.forEach(
-      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, validations, config }))
-    );
-  }
   return (0, import_flow.default)(validators);
 }
 function getNoSortEdges(fields = []) {
@@ -12042,322 +11633,26 @@ function getNoSortEdges(fields = []) {
     return list;
   }, []);
 }
-function getSchema(fields = [], config, validations) {
+function getSchema(fields = [], config) {
   const newSchema = {};
   fields.forEach((field) => {
     if (field.schema) {
       if (field.name) {
         if (field.inputType === supportedTypes.FIELDSET) {
-          const fieldsetSchema = buildYupSchema(
-            field,
-            { ...config, parentID: field.name },
-            validations
-          )();
+          const fieldsetSchema = buildYupSchema(field, config)();
           newSchema[field.name] = fieldsetSchema;
         } else {
           newSchema[field.name] = field.schema;
         }
       } else {
-        Object.assign(newSchema, getSchema(field.fields, config, validations));
+        Object.assign(newSchema, getSchema(field.fields, config));
       }
     }
   });
   return newSchema;
 }
-function buildCompleteYupSchema(fields, config, validations) {
-  return ObjectSchema().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(([, property2]) => property2.type === "object" || property2.type === "array").forEach(([key2, property2]) => {
-      if (property2.type === "array") {
-        createScopes(property2.items, `${key2}[]`);
-      }
-      createScopes(property2, 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, values2) {
-    return import_json_logic_js.default.apply(rule, clean(values2));
-  }
-  return {
-    validationMap,
-    computedValuesMap,
-    evaluateValidation,
-    evaluateValidationRuleInCondition(id, values2) {
-      const validation = validationMap.get(id);
-      if (validation === void 0)
-        throw Error(`"${id}" validation in if condition doesn't exist.`);
-      return evaluateValidation(validation.rule, values2);
-    },
-    evaluateComputedValueRuleForField(id, values2, fieldName) {
-      const validation = computedValuesMap.get(id);
-      if (validation === void 0)
-        throw Error(`"${id}" computedValue in field "${fieldName}" doesn't exist.`);
-      return evaluateValidation(validation.rule, values2);
-    },
-    evaluateComputedValueRuleInCondition(id, values2) {
-      const validation = computedValuesMap.get(id);
-      if (validation === void 0)
-        throw Error(`"${id}" computedValue in if condition doesn't exist.`);
-      return evaluateValidation(validation.rule, values2);
-    }
-  };
-}
-function clean(values2 = {}) {
-  return Object.entries(values2).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 import_json_logic_js.default.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(values2, formValues, parentID, validations, name) {
-  return Object.fromEntries(
-    Object.entries(values2).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(([, property2]) => property2["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property2]) => {
-    Object.entries(property2["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 = import_json_logic_js.default.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+$/, "");
+function buildCompleteYupSchema(fields, config) {
+  return ObjectSchema().shape(getSchema(fields, config), getNoSortEdges(fields));
 }
 
 // src/helpers.js
@@ -12367,8 +11662,8 @@ function hasType(type, typeName) {
 function getField(fieldName, fields) {
   return fields.find(({ name }) => name === fieldName);
 }
-function validateFieldSchema(field, value, validations) {
-  const validator = buildYupSchema(field, {}, validations);
+function validateFieldSchema(field, value) {
+  const validator = buildYupSchema(field);
   return validator().isValidSync(value);
 }
 function compareFormValueWithSchemaValue(formValue, schemaValue) {
@@ -12433,7 +11728,7 @@ function getPrefillValues(fields, initialValues = {}) {
   });
   return initialValues;
 }
-function updateField(field, requiredFields, node, formValues, validations, config) {
+function updateField(field, requiredFields, node, formValues) {
   if (!field) {
     return;
   }
@@ -12455,25 +11750,8 @@ function updateField(field, requiredFields, node, formValues, validations, confi
       }
     }
   });
-  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,
-      validations,
-      config,
-      formValues
-    );
+    const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
     updateValues(newFieldValues);
   }
   if (field.calculateCustomValidationProperties) {
@@ -12485,46 +11763,33 @@ function updateField(field, requiredFields, node, formValues, validations, confi
     updateValues(newFieldValues);
   }
 }
-function processNode({
-  node,
-  formValues,
-  formFields,
-  accRequired = /* @__PURE__ */ new Set(),
-  parentID = "root",
-  validations
-}) {
+function processNode(node, formValues, formFields, accRequired = /* @__PURE__ */ new Set()) {
   const requiredFields = new Set(accRequired);
   Object.keys(node.properties ?? []).forEach((fieldName) => {
     const field = getField(fieldName, formFields);
-    updateField(field, requiredFields, node, formValues, validations, { parentID });
+    updateField(field, requiredFields, node, formValues);
   });
   node.required?.forEach((fieldName) => {
     requiredFields.add(fieldName);
-    updateField(getField(fieldName, formFields), requiredFields, node, formValues, validations, {
-      parentID
-    });
+    updateField(getField(fieldName, formFields), requiredFields, node, formValues);
   });
   if (node.if) {
-    const matchesCondition = checkIfConditionMatches(node, formValues, formFields, validations);
+    const matchesCondition = checkIfConditionMatches(node, formValues, formFields);
     if (matchesCondition && node.then) {
-      const { required: branchRequired } = processNode({
-        node: node.then,
+      const { required: branchRequired } = processNode(
+        node.then,
         formValues,
         formFields,
-        accRequired: requiredFields,
-        parentID,
-        validations
-      });
+        requiredFields
+      );
       branchRequired.forEach((field) => requiredFields.add(field));
     } else if (node.else) {
-      const { required: branchRequired } = processNode({
-        node: node.else,
+      const { required: branchRequired } = processNode(
+        node.else,
         formValues,
         formFields,
-        accRequired: requiredFields,
-        parentID,
-        validations
-      });
+        requiredFields
+      );
       branchRequired.forEach((field) => requiredFields.add(field));
     }
   }
@@ -12536,21 +11801,12 @@ function processNode({
     node.anyOf.forEach(({ required: required2 = [] }) => {
       required2.forEach((fieldName) => {
         const field = getField(fieldName, formFields);
-        updateField(field, requiredFields, node, formValues, validations, { parentID });
+        updateField(field, requiredFields, node, formValues);
       });
     });
   }
   if (node.allOf) {
-    node.allOf.map(
-      (allOfNode) => processNode({
-        node: allOfNode,
-        formValues,
-        formFields,
-        accRequired: requiredFields,
-        parentID,
-        validations
-      })
-    ).forEach(({ required: allOfItemRequired }) => {
+    node.allOf.map((allOfNode) => processNode(allOfNode, formValues, formFields, requiredFields)).forEach(({ required: allOfItemRequired }) => {
       allOfItemRequired.forEach(requiredFields.add, requiredFields);
     });
   }
@@ -12558,27 +11814,10 @@ function processNode({
     Object.entries(node.properties).forEach(([name, nestedNode]) => {
       const inputType = getInputType(nestedNode);
       if (inputType === supportedTypes.FIELDSET) {
-        processNode({
-          node: nestedNode,
-          formValues: formValues[name] || {},
-          formFields: getField(name, formFields).fields,
-          validations,
-          parentID: name
-        });
+        processNode(nestedNode, formValues[name] || {}, getField(name, formFields).fields);
       }
     });
   }
-  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
   };
@@ -12593,11 +11832,11 @@ function clearValuesIfNotVisible(fields, formValues) {
     }
   });
 }
-function updateFieldsProperties(fields, formValues, jsonSchema, validations) {
+function updateFieldsProperties(fields, formValues, jsonSchema) {
   if (!jsonSchema?.properties) {
     return;
   }
-  processNode({ node: jsonSchema, formValues, formFields: fields, validations });
+  processNode(jsonSchema, formValues, fields);
   clearValuesIfNotVisible(fields, formValues);
 }
 var notNullOption = (opt) => opt.const !== null;
@@ -12640,20 +11879,12 @@ 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 = (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,
-      // 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 && {
@@ -12688,8 +11919,6 @@ function extractParametersFromNode(schemaNode) {
       },
       // Handle [name].presentation
       ...presentation,
-      requiredValidations,
-      computedAttributes: decoratedComputedAttributes,
       description: containsHTML(description) ? wrapWithSpan(description, {
         class: "jsf-description"
       }) : description,
@@ -12726,9 +11955,9 @@ function yupToFormErrors(yupError) {
   }
   return errors;
 }
-var handleValuesChange = (fields, jsonSchema, config, validations) => (values2) => {
-  updateFieldsProperties(fields, values2, jsonSchema, validations);
-  const lazySchema = lazy(() => buildCompleteYupSchema(fields, config, validations));
+var handleValuesChange = (fields, jsonSchema, config) => (values2) => {
+  updateFieldsProperties(fields, values2, jsonSchema);
+  const lazySchema = lazy(() => buildCompleteYupSchema(fields, config));
   let errors;
   try {
     lazySchema.validateSync(values2, {
@@ -12782,8 +12011,8 @@ function rebuildFieldset(fields, property2) {
     required: isFieldRequired(property2, field)
   }));
 }
-function calculateConditionalProperties(fieldParams, customProperties, validations, config) {
-  return (isRequired, conditionBranch, __, _, formValues) => {
+function calculateConditionalProperties(fieldParams, customProperties) {
+  return (isRequired, conditionBranch) => {
     const conditionalProperty = conditionBranch?.properties?.[fieldParams.name];
     if (conditionalProperty) {
       const presentation = pickXKey(conditionalProperty, "presentation") ?? {};
@@ -12797,31 +12026,17 @@ function calculateConditionalProperties(fieldParams, customProperties, validatio
         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 },
-        ...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
-        )
+        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
+        })
       };
       return (0, import_omit2.default)((0, import_merge2.default)(base, presentation, newFieldParams), ["inputType"]);
     }
@@ -12915,19 +12130,14 @@ function sortByOrderOrPosition(a, b, order) {
 function removeInvalidAttributes(fields) {
   return (0, import_omit3.default)(fields, ["items", "maxFileSize", "isDynamic"]);
 }
-function buildFieldParameters(name, fieldProperties, required2 = [], config = {}, validations) {
+function buildFieldParameters(name, fieldProperties, required2 = [], config = {}) {
   const { position } = pickXKey(fieldProperties, "presentation") ?? {};
   let fields;
   const inputType = getInputType(fieldProperties, config.strictInputType, name);
   if (inputType === supportedTypes.FIELDSET) {
-    fields = getFieldsFromJSONSchema(
-      fieldProperties,
-      {
-        customProperties: (0, import_get4.default)(config, `customProperties.${name}`, {}),
-        parentID: name
-      },
-      validations
-    );
+    fields = getFieldsFromJSONSchema(fieldProperties, {
+      customProperties: (0, import_get4.default)(config, `customProperties.${name}`, {})
+    });
   }
   const result = {
     name,
@@ -12942,9 +12152,9 @@ function buildFieldParameters(name, fieldProperties, required2 = [], config = {}
   };
   return (0, import_omitBy2.default)(result, import_isNil3.default);
 }
-function convertJSONSchemaPropertiesToFieldParameters({ properties, required: required2, "x-jsf-order": order }, config = {}, validations) {
+function convertJSONSchemaPropertiesToFieldParameters({ properties, required: required2, "x-jsf-order": order }, config = {}) {
   const sortFields2 = (a, b) => sortByOrderOrPosition(a, b, order);
-  return Object.entries(properties).filter(([, value]) => typeof value === "object").map(([key, value]) => buildFieldParameters(key, value, required2, config, validations)).sort(sortFields2).map(({ position, ...fieldParams }) => fieldParams);
+  return Object.entries(properties).filter(([, value]) => typeof value === "object").map(([key, value]) => buildFieldParameters(key, value, required2, config)).sort(sortFields2).map(({ position, ...fieldParams }) => fieldParams);
 }
 function applyFieldsDependencies(fieldsParameters, node) {
   if (node?.then) {
@@ -12966,9 +12176,6 @@ 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];
@@ -12980,16 +12187,15 @@ function getComposeFunctionForField(fieldParams, hasCustomizations) {
   }
   return composeFn;
 }
-function buildField(fieldParams, config, scopedJsonSchema, validations) {
+function buildField(fieldParams, config, scopedJsonSchema) {
   const customProperties = getCustomPropertiesForField(fieldParams, config);
   const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
-  const yupSchema = buildYupSchema(fieldParams, config, validations);
-  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties, validations, config);
+  const yupSchema = buildYupSchema(fieldParams, config);
+  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
@@ -13002,7 +12208,6 @@ function buildField(fieldParams, config, scopedJsonSchema, validations) {
     ...hasCustomValidations && {
       calculateCustomValidationProperties: calculateCustomValidationPropertiesClosure
     },
-    ...getComputedAttributes && { getComputedAttributes },
     // field customization properties
     ...customProperties && { fieldCustomization: customProperties },
     // base schema
@@ -13011,15 +12216,11 @@ function buildField(fieldParams, config, scopedJsonSchema, validations) {
   };
   return composeFn(finalFieldParams);
 }
-function getFieldsFromJSONSchema(scopedJsonSchema, config, validations) {
+function getFieldsFromJSONSchema(scopedJsonSchema, config) {
   if (!scopedJsonSchema) {
     return [];
   }
-  const fieldParamsList = convertJSONSchemaPropertiesToFieldParameters(
-    scopedJsonSchema,
-    config,
-    validations
-  );
+  const fieldParamsList = convertJSONSchemaPropertiesToFieldParameters(scopedJsonSchema, config);
   applyFieldsDependencies(fieldParamsList, scopedJsonSchema);
   const fields = [];
   fieldParamsList.forEach((fieldParams) => {
@@ -13039,11 +12240,11 @@ function getFieldsFromJSONSchema(scopedJsonSchema, config, validations) {
         fields: () => groupArrayFields,
         addFieldText: fieldParams.addFieldText
       };
-      buildField(fieldParams, config, scopedJsonSchema, validations).forEach((groupField) => {
+      buildField(fieldParams, config, scopedJsonSchema).forEach((groupField) => {
         fields.push(groupField);
       });
     } else {
-      fields.push(buildField(fieldParams, config, scopedJsonSchema, validations));
+      fields.push(buildField(fieldParams, config, scopedJsonSchema));
     }
   });
   return fields;
@@ -13054,15 +12255,9 @@ function createHeadlessForm(jsonSchema, customConfig = {}) {
     ...customConfig
   };
   try {
-    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
-    );
+    const fields = getFieldsFromJSONSchema(jsonSchema, config);
+    const handleValidation = handleValuesChange(fields, jsonSchema, config);
+    updateFieldsProperties(fields, getPrefillValues(fields, config.initialValues), jsonSchema);
     return {
       fields,
       handleValidation,