@remoteoss/json-schema-form 0.6.4-beta.0 → 0.6.5-beta.0

package/dist/index.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.6.4-beta.0
- Generated: Fri, 15 Sep 2023 12:36:13 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.5-beta.0
+ Generated: Mon, 18 Sep 2023 10:09:01 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 checkIfConditionMatchesProperties(node, formValues, formFields, logic) {
+  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".
@@ -91,10 +91,11 @@ function checkIfConditionMatches(node, formValues, formFields) {
       return currentProperty.enum.includes(value);
     }
     if (currentProperty.properties) {
-      return checkIfConditionMatches(
+      return checkIfConditionMatchesProperties(
         { if: currentProperty },
         formValues[name],
-        getField(name, formFields).fields
+        getField(name, formFields).fields,
+        logic
       );
     }
     const field = getField(name, formFields);
@@ -110,6 +111,23 @@ function checkIfConditionMatches(node, formValues, formFields) {
     );
   });
 }
+function checkIfMatchesValidationsAndComputedValues(node, formValues, logic, parentID) {
+  const validationsMatch = Object.entries(node.if.validations ?? {}).every(([name, property]) => {
+    const currentValue = logic.getScope(parentID).applyValidationRuleInCondition(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 = logic.getScope(parentID).applyComputedValueRuleInCondition(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,261 +388,14 @@ 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";
 import { randexp } from "randexp";
 import { string, number, boolean, object, array } from "yup";
-
-// src/jsonLogic.js
-import jsonLogic from "json-logic-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}[]`);
-      } else {
-        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(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
-    }
-    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
-    validationMap.set(id, validation);
-  });
-  computedValues.forEach(([id, computedValue]) => {
-    if (!computedValue.rule) {
-      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
-    }
-    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
-    computedValuesMap.set(id, computedValue);
-  });
-  function validate(rule, values) {
-    return jsonLogic.apply(rule, replaceUndefinedValuesWithNulls(values));
-  }
-  return {
-    validationMap,
-    computedValuesMap,
-    validate,
-    applyValidationRuleInCondition(id, values) {
-      const validation = validationMap.get(id);
-      return validate(validation.rule, values);
-    },
-    applyComputedValueInField(id, values, fieldName) {
-      const validation = computedValuesMap.get(id);
-      if (validation === void 0) {
-        throw Error(
-          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
-        );
-      }
-      return validate(validation.rule, values);
-    },
-    applyComputedValueRuleInCondition(id, values) {
-      const validation = computedValuesMap.get(id);
-      return validate(validation.rule, values);
-    }
-  };
-}
-function replaceUndefinedValuesWithNulls(values = {}) {
-  return Object.entries(values).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);
-  if (validation === void 0) {
-    throw Error(
-      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" 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);
-    }
-  );
-}
-var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
-function replaceHandlebarsTemplates({
-  value: toReplace,
-  logic,
-  formValues,
-  parentID,
-  name: fieldName
-}) {
-  if (typeof toReplace === "string") {
-    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
-      return logic.getScope(parentID).applyComputedValueInField(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 = logic.getScope(parentID).validate(rule, formValues);
-      return prev.replaceAll(`{{${key}}}`, computedValue);
-    }, value);
-    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
-      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
-    });
-  }
-  return toReplace;
-}
-function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
-  return ({ logic, isRequired, config, formValues }) => {
-    const { name, computedAttributes } = fieldParams;
-    const attributes = Object.fromEntries(
-      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
-    );
-    return {
-      ...attributes,
-      schema: buildYupSchema(
-        { ...fieldParams, ...attributes, required: isRequired },
-        config,
-        logic
-      )
-    };
-  };
-}
-function handleComputedAttribute(logic, formValues, parentID, name) {
-  return ([key, value]) => {
-    switch (key) {
-      case "description":
-        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-      case "title":
-        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-      case "x-jsf-errorMessage":
-        return [
-          "errorMessage",
-          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
-        ];
-      case "x-jsf-presentation": {
-        if (value.statement) {
-          return [
-            "statement",
-            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
-          ];
-        }
-        return [
-          key,
-          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
-        ];
-      }
-      case "const":
-      default: {
-        if (typeof value === "object" && value.rule) {
-          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
-        }
-        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
-      }
-    }
-  };
-}
-function handleNestedObjectForComputedValues(values, formValues, parentID, logic, name) {
-  return Object.fromEntries(
-    Object.entries(values).map(([key, value]) => {
-      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-    })
-  );
-}
-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) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
-        );
-      });
-    });
-  });
-}
-function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
-  Object.entries(rule ?? {}).map(([operator, subRule]) => {
-    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
-      return;
-    throwIfUnknownOperator(operator, subRule, id);
-    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 throwIfUnknownOperator(operator, subRule, id) {
-  try {
-    jsonLogic.apply({ [operator]: subRule });
-  } catch (e) {
-    if (e.message === `Unrecognized operation ${operator}`) {
-      throw Error(
-        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
-      );
-    }
-  }
-}
-var regexToGetIndices = /\.\d+\./g;
-function removeIndicesFromPath(path) {
-  const intermediatePath = path.replace(regexToGetIndices, ".");
-  return intermediatePath.replace(/\.\d+$/, "");
-}
-
-// src/yupSchema.js
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
 var baseString = string().trim();
 var todayDateHint = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
@@ -820,118 +591,414 @@ function buildYupSchema(field, config, logic) {
       }) : 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 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) {
+      return baseSchema.typeError(customErrorMsg);
+    }
+    return baseSchema;
+  }
+  function buildFieldSetSchema(innerFields) {
+    const fieldSetShape = {};
+    innerFields.forEach((fieldSetfield) => {
+      if (fieldSetfield.fields) {
+        fieldSetShape[fieldSetfield.name] = object().shape(
+          buildFieldSetSchema(fieldSetfield.fields)
+        );
+      } else {
+        fieldSetShape[fieldSetfield.name] = buildYupSchema(
+          {
+            ...fieldSetfield,
+            inputType: fieldSetfield.type
+          },
+          config
+        )();
+      }
+    });
+    return fieldSetShape;
+  }
+  function buildGroupArraySchema() {
+    return object().shape(
+      propertyFields.nthFieldGroup.fields().reduce(
+        (schema, groupArrayField) => ({
+          ...schema,
+          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
+        }),
+        {}
+      )
+    );
+  }
+  const validators = [withBaseSchema];
+  if (inputType === supportedTypes.GROUP_ARRAY) {
+    validators[0] = () => withBaseSchema().of(buildGroupArraySchema());
+  } else if (inputType === supportedTypes.FIELDSET) {
+    validators[0] = () => withBaseSchema().shape(buildFieldSetSchema(propertyFields.fields));
+  }
+  if (propertyFields.required) {
+    validators.push(withRequired);
+  }
+  if (typeof propertyFields.minimum !== "undefined") {
+    validators.push(withMin);
+  }
+  if (typeof propertyFields.minLength !== "undefined") {
+    validators.push(withMinLength);
+  }
+  if (propertyFields.maximum !== void 0) {
+    validators.push(withMax);
+  }
+  if (propertyFields.maxLength) {
+    validators.push(withMaxLength);
+  }
+  if (propertyFields.pattern) {
+    validators.push(withMatches);
+  }
+  if (propertyFields.maxFileSize) {
+    validators.push(withMaxFileSize);
+  }
+  if (propertyFields.accept) {
+    validators.push(withFileFormat);
+  }
+  if (propertyFields.const) {
+    validators.push(withConst);
+  }
+  if (propertyFields.jsonLogicValidations) {
+    propertyFields.jsonLogicValidations.forEach(
+      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, logic, config }))
+    );
+  }
+  return flow(validators);
+}
+function getNoSortEdges(fields = []) {
+  return fields.reduce((list, field) => {
+    if (field.noSortEdges) {
+      list.push(field.name);
+    }
+    return list;
+  }, []);
+}
+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)();
+          newSchema[field.name] = fieldsetSchema;
+        } else {
+          newSchema[field.name] = field.schema;
+        }
+      } else {
+        Object.assign(newSchema, getSchema(field.fields, config));
+      }
+    }
+  });
+  return newSchema;
+}
+function buildCompleteYupSchema(fields, config) {
+  return object().shape(getSchema(fields, config), 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}[]`);
+      } else {
+        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(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
+    validationMap.set(id, validation);
+  });
+  computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
+    computedValuesMap.set(id, computedValue);
+  });
+  function validate(rule, values) {
+    return jsonLogic.apply(
+      rule,
+      replaceUndefinedValuesWithNulls({ ...sampleEmptyObject, ...values })
+    );
+  }
+  return {
+    validationMap,
+    computedValuesMap,
+    validate,
+    applyValidationRuleInCondition(id, values) {
+      const validation = validationMap.get(id);
+      return validate(validation.rule, values);
+    },
+    applyComputedValueInField(id, values, fieldName) {
+      const validation = computedValuesMap.get(id);
+      if (validation === void 0) {
+        throw Error(
+          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
+        );
+      }
+      return validate(validation.rule, values);
+    },
+    applyComputedValueRuleInCondition(id, values) {
+      const validation = computedValuesMap.get(id);
+      return validate(validation.rule, values);
+    }
+  };
+}
+function replaceUndefinedValuesWithNulls(values = {}) {
+  return Object.entries(values).reduce((prev, [key, value]) => {
+    return { ...prev, [key]: value === void 0 || value === null ? NaN : value };
+  }, {});
+}
+function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
+  const { parentID = "root" } = config;
+  const validation = logic.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(
+      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" 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);
+    }
+  );
+}
+var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  logic,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(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 = logic.getScope(parentID).validate(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  }
+  return toReplace;
+}
+function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
+  return ({ logic, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
+    const attributes = Object.fromEntries(
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
     );
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        logic
+      )
+    };
+  };
+}
+function handleComputedAttribute(logic, formValues, parentID, name) {
+  return ([key, value]) => {
+    switch (key) {
+      case "description":
+        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "title":
+        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "x-jsf-errorMessage":
+        return [
+          "errorMessage",
+          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
+        ];
+      case "x-jsf-presentation": {
+        if (value.statement) {
+          return [
+            "statement",
+            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+          ];
+        }
+        return [
+          key,
+          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+        ];
+      }
+      case "const":
+      default: {
+        if (typeof value === "object" && value.rule) {
+          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
+        }
+        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
+      }
+    }
+  };
+}
+function handleNestedObjectForComputedValues(values, formValues, parentID, logic, name) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+    })
+  );
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
   }
-  function withBaseSchema() {
-    const customErrorMsg = errorMessage.type || errorMessageFromConfig.type;
-    if (customErrorMsg) {
-      return baseSchema.typeError(customErrorMsg);
+  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 baseSchema;
   }
-  function buildFieldSetSchema(innerFields) {
-    const fieldSetShape = {};
-    innerFields.forEach((fieldSetfield) => {
-      if (fieldSetfield.fields) {
-        fieldSetShape[fieldSetfield.name] = object().shape(
-          buildFieldSetSchema(fieldSetfield.fields)
+  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) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
         );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
+  Object.entries(rule ?? {}).map(([operator, subRule]) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    throwIfUnknownOperator(operator, subRule, id);
+    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 {
-        fieldSetShape[fieldSetfield.name] = buildYupSchema(
-          {
-            ...fieldSetfield,
-            inputType: fieldSetfield.type
-          },
-          config
-        )();
+        checkRuleIntegrity(item, id, data);
       }
     });
-    return fieldSetShape;
-  }
-  function buildGroupArraySchema() {
-    return object().shape(
-      propertyFields.nthFieldGroup.fields().reduce(
-        (schema, groupArrayField) => ({
-          ...schema,
-          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
-        }),
-        {}
-      )
-    );
-  }
-  const validators = [withBaseSchema];
-  if (inputType === supportedTypes.GROUP_ARRAY) {
-    validators[0] = () => withBaseSchema().of(buildGroupArraySchema());
-  } else if (inputType === supportedTypes.FIELDSET) {
-    validators[0] = () => withBaseSchema().shape(buildFieldSetSchema(propertyFields.fields));
-  }
-  if (propertyFields.required) {
-    validators.push(withRequired);
-  }
-  if (typeof propertyFields.minimum !== "undefined") {
-    validators.push(withMin);
-  }
-  if (typeof propertyFields.minLength !== "undefined") {
-    validators.push(withMinLength);
-  }
-  if (propertyFields.maximum !== void 0) {
-    validators.push(withMax);
-  }
-  if (propertyFields.maxLength) {
-    validators.push(withMaxLength);
-  }
-  if (propertyFields.pattern) {
-    validators.push(withMatches);
-  }
-  if (propertyFields.maxFileSize) {
-    validators.push(withMaxFileSize);
-  }
-  if (propertyFields.accept) {
-    validators.push(withFileFormat);
+  });
+}
+function throwIfUnknownOperator(operator, subRule, id) {
+  try {
+    jsonLogic.apply({ [operator]: subRule });
+  } catch (e) {
+    if (e.message === `Unrecognized operation ${operator}`) {
+      throw Error(
+        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
+      );
+    }
   }
-  if (propertyFields.const) {
-    validators.push(withConst);
+}
+var regexToGetIndices = /\.\d+\./g;
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(regexToGetIndices, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
+}
+function processJSONLogicNode({
+  node,
+  formFields,
+  formValues,
+  accRequired,
+  parentID,
+  logic
+}) {
+  const requiredFields = new Set(accRequired);
+  if (node.allOf) {
+    node.allOf.map(
+      (allOfNode) => processJSONLogicNode({ node: allOfNode, formValues, formFields, logic, parentID })
+    ).forEach(({ required: allOfItemRequired }) => {
+      allOfItemRequired.forEach(requiredFields.add, requiredFields);
+    });
   }
-  if (propertyFields.requiredValidations) {
-    propertyFields.requiredValidations.forEach(
-      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, logic, config }))
+  if (node.if) {
+    const matchesPropertyCondition = checkIfConditionMatchesProperties(
+      node,
+      formValues,
+      formFields,
+      logic
     );
-  }
-  return flow(validators);
-}
-function getNoSortEdges(fields = []) {
-  return fields.reduce((list, field) => {
-    if (field.noSortEdges) {
-      list.push(field.name);
+    const matchesValidationsAndComputedValues = matchesPropertyCondition && checkIfMatchesValidationsAndComputedValues(node, formValues, logic, parentID);
+    const isConditionMatch = matchesPropertyCondition && matchesValidationsAndComputedValues;
+    let nextNode;
+    if (isConditionMatch && node.then) {
+      nextNode = node.then;
     }
-    return list;
-  }, []);
-}
-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)();
-          newSchema[field.name] = fieldsetSchema;
-        } else {
-          newSchema[field.name] = field.schema;
-        }
-      } else {
-        Object.assign(newSchema, getSchema(field.fields, config));
-      }
+    if (!isConditionMatch && node.else) {
+      nextNode = node.else;
     }
-  });
-  return newSchema;
-}
-function buildCompleteYupSchema(fields, config) {
-  return object().shape(getSchema(fields, config), getNoSortEdges(fields));
+    if (nextNode) {
+      const { required: branchRequired } = processNode({
+        node: nextNode,
+        formValues,
+        formFields,
+        accRequired,
+        logic,
+        parentID
+      });
+      branchRequired.forEach((field) => requiredFields.add(field));
+    }
+  }
+  return { required: requiredFields };
 }
 
 // src/helpers.js
@@ -1050,7 +1117,11 @@ function updateField(field, requiredFields, node, formValues, logic, config) {
     updateValues(computedFieldValues);
   }
   if (field.calculateConditionalProperties) {
-    const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
+    const newFieldValues = field.calculateConditionalProperties({
+      isRequired: fieldIsRequired,
+      conditionBranch: node,
+      formValues
+    });
     updateValues(newFieldValues);
   }
   if (field.calculateCustomValidationProperties) {
@@ -1082,7 +1153,7 @@ function processNode({
     });
   });
   if (node.if) {
-    const matchesCondition = checkIfConditionMatches(node, formValues, formFields, logic);
+    const matchesCondition = checkIfConditionMatchesProperties(node, formValues, formFields, logic);
     if (matchesCondition && node.then) {
       const { required: branchRequired } = processNode({
         node: node.then,
@@ -1145,6 +1216,17 @@ function processNode({
       }
     });
   }
+  if (node["x-jsf-logic"]) {
+    const { required: requiredFromLogic } = processJSONLogicNode({
+      node: node["x-jsf-logic"],
+      formValues,
+      formFields,
+      accRequired: requiredFields,
+      parentID,
+      logic
+    });
+    requiredFromLogic.forEach((field) => requiredFields.add(field));
+  }
   return {
     required: requiredFields
   };
@@ -1206,7 +1288,7 @@ function extractParametersFromNode(schemaNode) {
   }
   const presentation = pickXKey(schemaNode, "presentation") ?? {};
   const errorMessage = pickXKey(schemaNode, "errorMessage") ?? {};
-  const requiredValidations = schemaNode["x-jsf-logic-validations"];
+  const jsonLogicValidations = schemaNode["x-jsf-logic-validations"];
   const computedAttributes = schemaNode["x-jsf-logic-computedAttrs"];
   const decoratedComputedAttributes = getDecoratedComputedAttributes(computedAttributes);
   const node = omit(schemaNode, ["x-jsf-presentation", "presentation"]);
@@ -1250,7 +1332,7 @@ function extractParametersFromNode(schemaNode) {
       },
       // Handle [name].presentation
       ...presentation,
-      requiredValidations,
+      jsonLogicValidations,
       computedAttributes: decoratedComputedAttributes,
       description: containsHTML(description) ? wrapWithSpan(description, {
         class: "jsf-description"
@@ -1350,8 +1432,8 @@ function rebuildFieldset(fields, property) {
     required: isFieldRequired(property, field)
   }));
 }
-function calculateConditionalProperties(fieldParams, customProperties) {
-  return (isRequired, conditionBranch) => {
+function calculateConditionalProperties({ fieldParams, customProperties, logic, config }) {
+  return ({ isRequired, conditionBranch, formValues }) => {
     const conditionalProperty = conditionBranch?.properties?.[fieldParams.name];
     if (conditionalProperty) {
       const presentation = pickXKey(conditionalProperty, "presentation") ?? {};
@@ -1365,17 +1447,31 @@ function calculateConditionalProperties(fieldParams, customProperties) {
         fieldSetFields = rebuildFieldset(fieldParams.fields, conditionalProperty);
         newFieldParams.fields = fieldSetFields;
       }
+      const { computedAttributes, ...restNewFieldParams } = newFieldParams;
+      const calculatedComputedAttributes = computedAttributes ? calculateComputedAttributes(newFieldParams, config)({ logic, formValues }) : {};
+      const jsonLogicValidations = [
+        ...fieldParams.jsonLogicValidations ?? [],
+        ...restNewFieldParams.jsonLogicValidations ?? []
+      ];
       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,
+            jsonLogicValidations,
+            // If there are inner fields (case of fieldset) they need to be updated based on the condition
+            fields: fieldSetFields,
+            required: isRequired
+          },
+          config,
+          logic
+        )
       };
       return omit2(merge2(base, presentation, newFieldParams), ["inputType"]);
     }
@@ -1469,14 +1565,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 = {}, logic) {
   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
+      },
+      logic
+    );
   }
   const result = {
     name,
@@ -1533,7 +1634,7 @@ function buildField(fieldParams, config, scopedJsonSchema, logic) {
   const customProperties = getCustomPropertiesForField(fieldParams, config);
   const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
   const yupSchema = buildYupSchema(fieldParams, config, logic);
-  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties);
+  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties({ fieldParams, customProperties, logic, config });
   const calculateCustomValidationPropertiesClosure = calculateCustomValidationProperties(
     fieldParams,
     customProperties