@remoteoss/json-schema-form 0.1.0-dev.20230517211625

package/dist/index.js

@@ -0,0 +1,1174 @@
+
+/*!
+ Copyright (c) 2023 Remote Technology, Inc.
+ NPM Package: @remoteoss/json-schema-form@0.1.0-dev.20230517211625
+ Generated: Wed, 17 May 2023 21:17:44 GMT
+
+ MIT License
+
+Copyright (c) 2023 Remote Technology, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/ 
+
+// src/createHeadlessForm.js
+import get3 from "lodash/get";
+import isNil3 from "lodash/isNil";
+import omit3 from "lodash/omit";
+import omitBy2 from "lodash/omitBy";
+import pick2 from "lodash/pick";
+import size from "lodash/size";
+
+// src/calculateConditionalProperties.js
+import merge2 from "lodash/merge";
+import omit2 from "lodash/omit";
+
+// src/helpers.js
+import get2 from "lodash/get";
+import isNil from "lodash/isNil";
+import omit from "lodash/omit";
+import omitBy from "lodash/omitBy";
+import set from "lodash/set";
+import { lazy } from "yup";
+
+// src/internals/helpers.js
+import merge from "lodash/fp/merge";
+import get from "lodash/get";
+import isEmpty from "lodash/isEmpty";
+import isFunction from "lodash/isFunction";
+function pickXKey(node, key) {
+  const deprecatedKeys = ["presentation", "errorMessage"];
+  return get(node, `x-jsf-${key}`, deprecatedKeys.includes(key) ? node?.[key] : void 0);
+}
+function getFieldDescription(node, customProperties = {}) {
+  const nodeDescription = node?.description ? {
+    description: node.description
+  } : {};
+  const customDescription = customProperties?.description ? {
+    description: isFunction(customProperties.description) ? customProperties.description(node?.description, {
+      ...node,
+      ...customProperties
+    }) : customProperties.description
+  } : {};
+  const nodePresentation = pickXKey(node, "presentation");
+  const presentation = !isEmpty(nodePresentation) && {
+    presentation: { ...nodePresentation, ...customDescription }
+  };
+  return merge(nodeDescription, { ...customDescription, ...presentation });
+}
+
+// src/internals/fields.js
+var jsonTypes = {
+  STRING: "string",
+  NUMBER: "number",
+  INTEGER: "integer",
+  OBJECT: "object",
+  ARRAY: "array",
+  BOOLEAN: "boolean",
+  NULL: "null"
+};
+var supportedTypes = {
+  TEXT: "text",
+  NUMBER: "number",
+  SELECT: "select",
+  FILE: "file",
+  RADIO: "radio",
+  GROUP_ARRAY: "group-array",
+  EMAIL: "email",
+  DATE: "date",
+  CHECKBOX: "checkbox",
+  FIELDSET: "fieldset"
+};
+var jsonTypeToInputType = {
+  [jsonTypes.STRING]: ({ oneOf, format }) => {
+    if (format === "email")
+      return supportedTypes.EMAIL;
+    if (format === "date")
+      return supportedTypes.DATE;
+    if (format === "data-url")
+      return supportedTypes.FILE;
+    if (oneOf)
+      return supportedTypes.RADIO;
+    return supportedTypes.TEXT;
+  },
+  [jsonTypes.NUMBER]: () => supportedTypes.NUMBER,
+  [jsonTypes.INTEGER]: () => supportedTypes.NUMBER,
+  [jsonTypes.OBJECT]: () => supportedTypes.FIELDSET,
+  [jsonTypes.ARRAY]: ({ items }) => {
+    if (items.properties)
+      return supportedTypes.GROUP_ARRAY;
+    return supportedTypes.SELECT;
+  },
+  [jsonTypes.BOOLEAN]: () => supportedTypes.CHECKBOX
+};
+function getInputType(fieldProperties, strictInputType, name) {
+  const presentation = pickXKey(fieldProperties, "presentation") ?? {};
+  const presentationInputType = presentation?.inputType;
+  if (presentationInputType) {
+    return presentationInputType;
+  }
+  if (strictInputType) {
+    throw Error(`Strict error: Missing inputType to field "${name || fieldProperties.title}".
+You can fix the json schema or skip this error by calling createHeadlessForm(schema, { strictInputType: false })`);
+  }
+  if (!fieldProperties.type) {
+    if (fieldProperties.items?.properties) {
+      return supportedTypes.GROUP_ARRAY;
+    }
+    if (fieldProperties.properties) {
+      return supportedTypes.SELECT;
+    }
+    return jsonTypeToInputType[jsonTypes.STRING](fieldProperties);
+  }
+  return jsonTypeToInputType[fieldProperties.type]?.(fieldProperties);
+}
+function _composeFieldFile({ name, label, description, accept, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.FILE,
+    name,
+    label,
+    description,
+    required,
+    accept,
+    ...attrs
+  };
+}
+function _composeFieldText({ name, label, description, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.TEXT,
+    name,
+    label,
+    description,
+    required,
+    ...attrs
+  };
+}
+function _composeFieldEmail({ name, label, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.EMAIL,
+    name,
+    label,
+    required,
+    ...attrs
+  };
+}
+function _composeFieldNumber({
+  name,
+  label,
+  percentage = false,
+  required = true,
+  minimum,
+  maximum,
+  ...attrs
+}) {
+  let minValue = minimum;
+  let maxValue = maximum;
+  if (percentage) {
+    minValue = minValue ?? 0;
+    maxValue = maxValue ?? 100;
+  }
+  return {
+    type: supportedTypes.NUMBER,
+    name,
+    label,
+    percentage,
+    required,
+    minimum: minValue,
+    maximum: maxValue,
+    ...attrs
+  };
+}
+function _composeFieldDate({ name, label, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.DATE,
+    name,
+    label,
+    required,
+    ...attrs
+  };
+}
+function _composeFieldRadio({ name, label, options, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.RADIO,
+    name,
+    label,
+    options,
+    required,
+    ...attrs
+  };
+}
+function _composeFieldSelect({ name, label, options, required = true, ...attrs }) {
+  return {
+    type: supportedTypes.SELECT,
+    name,
+    label,
+    options,
+    required,
+    ...attrs
+  };
+}
+function _composeNthFieldGroup({ name, label, required, nthFieldGroup, ...attrs }) {
+  return [
+    {
+      ...nthFieldGroup,
+      type: supportedTypes.GROUP_ARRAY,
+      name,
+      label,
+      required,
+      ...attrs
+    }
+  ];
+}
+function _composeFieldCheckbox({
+  required = true,
+  name,
+  label,
+  description,
+  default: defaultValue,
+  checkboxValue,
+  ...attrs
+}) {
+  return {
+    type: supportedTypes.CHECKBOX,
+    required,
+    name,
+    label,
+    description,
+    checkboxValue,
+    ...defaultValue && { default: defaultValue },
+    ...attrs
+  };
+}
+function _composeFieldset({ name, label, fields, variant, ...attrs }) {
+  return {
+    type: supportedTypes.FIELDSET,
+    name,
+    label,
+    fields,
+    variant,
+    ...attrs
+  };
+}
+var _composeFieldArbitraryClosure = (inputType) => (attrs) => ({
+  type: inputType,
+  ...attrs
+});
+var inputTypeMap = {
+  text: _composeFieldText,
+  select: _composeFieldSelect,
+  radio: _composeFieldRadio,
+  date: _composeFieldDate,
+  number: _composeFieldNumber,
+  "group-array": _composeNthFieldGroup,
+  fieldset: _composeFieldset,
+  file: _composeFieldFile,
+  email: _composeFieldEmail,
+  checkbox: _composeFieldCheckbox
+};
+function _composeFieldCustomClosure(defaultComposeFn) {
+  return ({ fieldCustomization, ...attrs }) => {
+    const { description, ...restFieldCustomization } = fieldCustomization;
+    const fieldDescription = getFieldDescription(attrs, fieldCustomization);
+    const { nthFieldGroup, ...restAttrs } = attrs;
+    const commonAttrs = {
+      ...restAttrs,
+      ...restFieldCustomization,
+      ...fieldDescription
+    };
+    if (attrs.inputType === supportedTypes.GROUP_ARRAY) {
+      return [
+        {
+          ...nthFieldGroup,
+          ...commonAttrs
+        }
+      ];
+    }
+    return {
+      ...defaultComposeFn(attrs),
+      ...commonAttrs
+    };
+  };
+}
+
+// src/utils.js
+function convertDiskSizeFromTo(from, to) {
+  const units = ["bytes", "kb", "mb"];
+  return function convert(value) {
+    return value * Math.pow(1024, units.indexOf(from.toLowerCase())) / Math.pow(1024, units.indexOf(to.toLowerCase()));
+  };
+}
+function containsHTML(str = "") {
+  return /<[a-z][\s\S]*>/i.test(str);
+}
+function wrapWithSpan(html, properties = {}) {
+  const attributes = Object.entries(properties).reduce((acc, [key, value]) => `${acc}${key}="${value}" `, "").trim();
+  return `<span ${attributes}>${html}</span>`;
+}
+function hasProperty(object2, propertyName) {
+  return Object.prototype.hasOwnProperty.call(object2, propertyName);
+}
+
+// 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";
+var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
+var baseString = string().trim();
+var todayDateHint = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+var convertBytesToKB = convertDiskSizeFromTo("Bytes", "KB");
+var convertKbBytesToMB = convertDiskSizeFromTo("KB", "MB");
+var yupSchemas = {
+  text: string().trim().nullable(),
+  select: string().trim().nullable(),
+  radio: string().trim().nullable(),
+  date: string().nullable().trim().matches(
+    /(?:\d){4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-9]|3[0-1])/,
+    `Must be a valid date in ${DEFAULT_DATE_FORMAT.toLocaleLowerCase()} format. e.g. ${todayDateHint}`
+  ),
+  number: number().typeError("The value must be a number").nullable(),
+  file: array().nullable(),
+  email: string().trim().email("Please enter a valid email address").nullable(),
+  fieldset: object().nullable(),
+  checkbox: string().trim().nullable(),
+  checkboxBool: boolean(),
+  multiple: {
+    select: array().nullable(),
+    "group-array": array().nullable()
+  }
+};
+var yupSchemasToJsonTypes = {
+  string: yupSchemas.text,
+  number: yupSchemas.number,
+  integer: yupSchemas.number,
+  object: yupSchemas.fieldset,
+  array: yupSchemas.multiple.select,
+  boolean: yupSchemas.checkboxBool,
+  null: noop
+};
+function getRequiredErrorMessage(inputType, { inlineError, configError }) {
+  if (inlineError)
+    return inlineError;
+  if (configError)
+    return configError;
+  if (inputType === supportedTypes.CHECKBOX)
+    return "Please acknowledge this field";
+  return "Required field";
+}
+var getJsonTypeInArray = (jsonType) => Array.isArray(jsonType) ? jsonType.find((val) => val !== "null") : jsonType;
+function buildYupSchema(field, config) {
+  const { inputType, jsonType: jsonTypeValue, errorMessage = {}, ...propertyFields } = field;
+  const isCheckboxBoolean = typeof propertyFields.checkboxValue === "boolean";
+  let baseSchema;
+  const jsonType = getJsonTypeInArray(jsonTypeValue);
+  const errorMessageFromConfig = config?.inputTypes?.[inputType]?.errorMessage || {};
+  if (propertyFields.multiple) {
+    baseSchema = yupSchemas.multiple[inputType] || yupSchemasToJsonTypes.array;
+  } else if (isCheckboxBoolean) {
+    baseSchema = yupSchemas.checkboxBool;
+  } else {
+    baseSchema = yupSchemas[inputType] || yupSchemasToJsonTypes[jsonType];
+  }
+  if (!baseSchema) {
+    return noop;
+  }
+  const randomPlaceholder = propertyFields.pattern && randexp(propertyFields.pattern);
+  const requiredMessage = getRequiredErrorMessage(inputType, {
+    inlineError: errorMessage.required,
+    configError: errorMessageFromConfig.required
+  });
+  function withRequired(yupSchema) {
+    if (isCheckboxBoolean) {
+      return yupSchema.oneOf([true], requiredMessage).required(requiredMessage);
+    }
+    return yupSchema.required(requiredMessage);
+  }
+  function withMin(yupSchema) {
+    return yupSchema.min(
+      propertyFields.minimum,
+      (message) => errorMessage.minimum ?? errorMessageFromConfig.minimum ?? `Must be greater or equal to ${message.min}`
+    );
+  }
+  function withMinLength(yupSchema) {
+    return yupSchema.min(
+      propertyFields.minLength,
+      (message) => errorMessage.minLength ?? errorMessageFromConfig.minLength ?? `Please insert at least ${message.min} characters`
+    );
+  }
+  function withMax(yupSchema) {
+    return yupSchema.max(
+      propertyFields.maximum,
+      (message) => errorMessage.maximum ?? errorMessageFromConfig.maximum ?? `Must be smaller or equal to ${message.max}`
+    );
+  }
+  function withMaxLength(yupSchema) {
+    return yupSchema.max(
+      propertyFields.maxLength,
+      (message) => errorMessage.maxLength ?? errorMessageFromConfig.maxLength ?? `Please insert up to ${message.max} characters`
+    );
+  }
+  function withMatches(yupSchema) {
+    return yupSchema.matches(
+      propertyFields.pattern,
+      () => errorMessage.pattern ?? errorMessageFromConfig.pattern ?? `Must have a valid format. E.g. ${randomPlaceholder}`
+    );
+  }
+  function withMaxFileSize(yupSchema) {
+    return yupSchema.test(
+      "isValidFileSize",
+      errorMessage.maxFileSize ?? errorMessageFromConfig.maxFileSize ?? `File size too large. The limit is ${convertKbBytesToMB(propertyFields.maxFileSize)} MB.`,
+      (files) => !files?.some((file) => convertBytesToKB(file.size) > propertyFields.maxFileSize)
+    );
+  }
+  function withFileFormat(yupSchema) {
+    return yupSchema.test(
+      "isSupportedFormat",
+      errorMessage.accept ?? errorMessageFromConfig.accept ?? `Unsupported file format. The acceptable formats are ${propertyFields.accept}.`,
+      (files) => files && files?.length > 0 ? files.some((file) => {
+        const fileType = file.name.split(".").pop();
+        return propertyFields.accept.includes(fileType.toLowerCase());
+      }) : true
+    );
+  }
+  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) {
+    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);
+  }
+  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/helpers.js
+function hasType(type, typeName) {
+  return Array.isArray(type) ? type.includes(typeName) : type === typeName;
+}
+function getField(fieldName, fields) {
+  return fields.find(({ name }) => name === fieldName);
+}
+function validateFieldSchema(field, value) {
+  const validator = buildYupSchema(field);
+  return validator().isValidSync(value);
+}
+function compareFormValueWithSchemaValue(formValue, schemaValue) {
+  const currentPropertyValue = typeof schemaValue === "number" ? schemaValue : schemaValue || void 0;
+  return String(formValue) === String(currentPropertyValue);
+}
+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".
+    value === null;
+    const hasIfExplicit = node.if.required?.includes(name);
+    if (hasEmptyValue && !hasIfExplicit) {
+      return true;
+    }
+    if (hasProperty(currentProperty, "const")) {
+      return compareFormValueWithSchemaValue(value, currentProperty.const);
+    }
+    if (currentProperty.contains?.pattern) {
+      const formValue = value || [];
+      if (Array.isArray(formValue)) {
+        const pattern = new RegExp(currentProperty.contains.pattern);
+        return (value || []).some((item) => pattern.test(item));
+      }
+    }
+    if (currentProperty.enum) {
+      return currentProperty.enum.includes(value);
+    }
+    const { inputType } = getField(name, formFields);
+    return validateFieldSchema({ ...currentProperty, inputType, required: true }, value);
+  });
+}
+function isFieldFilled(fieldValue) {
+  return Array.isArray(fieldValue) ? fieldValue.length > 0 : !!fieldValue;
+}
+function findFirstAnyOfMatch(nodes, formValues) {
+  return nodes.find(
+    ({ required }) => required?.some((fieldName) => isFieldFilled(formValues[fieldName]))
+  ) || nodes[0];
+}
+function getPrefillSubFieldValues(field, defaultValues, parentFieldKeyPath) {
+  let initialValue = defaultValues ?? {};
+  let fieldKeyPath = field.name;
+  if (parentFieldKeyPath) {
+    fieldKeyPath = fieldKeyPath ? `${parentFieldKeyPath}.${fieldKeyPath}` : parentFieldKeyPath;
+  }
+  const subFields = field.fields;
+  if (Array.isArray(subFields)) {
+    const subFieldValues = {};
+    subFields.forEach((subField) => {
+      Object.assign(
+        subFieldValues,
+        getPrefillSubFieldValues(subField, initialValue[field.name], fieldKeyPath)
+      );
+    });
+    if (field.inputType === supportedTypes.FIELDSET && field.valueGroupingDisabled) {
+      Object.assign(initialValue, subFieldValues);
+    } else {
+      initialValue[field.name] = subFieldValues;
+    }
+  } else {
+    initialValue = getPrefillValues([field], initialValue);
+  }
+  return initialValue;
+}
+function getPrefillValues(fields, initialValues = {}) {
+  fields.forEach((field) => {
+    const fieldName = field.name;
+    switch (field.type) {
+      case supportedTypes.GROUP_ARRAY: {
+        initialValues[fieldName] = initialValues[fieldName]?.map(
+          (subFieldValues) => getPrefillValues(field.fields(), subFieldValues)
+        );
+        break;
+      }
+      case supportedTypes.FIELDSET: {
+        const subFieldValues = getPrefillSubFieldValues(field, initialValues);
+        Object.assign(initialValues, subFieldValues);
+        break;
+      }
+      default: {
+        if (!initialValues[fieldName]) {
+          initialValues[fieldName] = field.default;
+        }
+        break;
+      }
+    }
+  });
+  return initialValues;
+}
+function updateField(field, requiredFields, node, formValues) {
+  if (!field) {
+    return;
+  }
+  const fieldIsRequired = requiredFields.has(field.name);
+  if (node.properties && hasProperty(node.properties, field.name)) {
+    field.isVisible = !!node.properties[field.name];
+  }
+  if (fieldIsRequired) {
+    field.isVisible = true;
+  }
+  const updateValues = (fieldValues) => Object.entries(fieldValues).forEach(([key, value]) => {
+    field[key] = typeof value === "function" ? value() : value;
+    if (key === "value") {
+      const readOnlyPropertyWasUpdated = typeof fieldValues.readOnly !== "undefined";
+      const isReadonlyByDefault = field.readOnly;
+      const isReadonly = readOnlyPropertyWasUpdated ? fieldValues.readOnly : isReadonlyByDefault;
+      if (!isReadonly && (value === null || field.inputType === "checkbox")) {
+        field.value = void 0;
+      }
+    }
+  });
+  if (field.calculateConditionalProperties) {
+    const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
+    updateValues(newFieldValues);
+  }
+  if (field.calculateCustomValidationProperties) {
+    const newFieldValues = field.calculateCustomValidationProperties(
+      fieldIsRequired,
+      node,
+      formValues
+    );
+    updateValues(newFieldValues);
+  }
+}
+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);
+  });
+  node.required?.forEach((fieldName) => {
+    requiredFields.add(fieldName);
+    updateField(getField(fieldName, formFields), requiredFields, node, formValues);
+  });
+  if (node.if) {
+    const matchesCondition = checkIfConditionMatches(node, formValues, formFields);
+    if (matchesCondition && node.then) {
+      const { required: branchRequired } = processNode(
+        node.then,
+        formValues,
+        formFields,
+        requiredFields
+      );
+      branchRequired.forEach((field) => requiredFields.add(field));
+    } else if (node.else) {
+      const { required: branchRequired } = processNode(
+        node.else,
+        formValues,
+        formFields,
+        requiredFields
+      );
+      branchRequired.forEach((field) => requiredFields.add(field));
+    }
+  }
+  if (node.anyOf) {
+    const firstMatchOfAnyOf = findFirstAnyOfMatch(node.anyOf, formValues);
+    firstMatchOfAnyOf.required?.forEach((fieldName) => {
+      requiredFields.add(fieldName);
+    });
+    node.anyOf.forEach(({ required = [] }) => {
+      required.forEach((fieldName) => {
+        const field = getField(fieldName, formFields);
+        updateField(field, requiredFields, node, formValues);
+      });
+    });
+  }
+  if (node.allOf) {
+    node.allOf.map((allOfNode) => processNode(allOfNode, formValues, formFields, requiredFields)).forEach(({ required: allOfItemRequired }) => {
+      allOfItemRequired.forEach(requiredFields.add, requiredFields);
+    });
+  }
+  if (node.properties) {
+    Object.entries(node.properties).forEach(([name, nestedNode]) => {
+      const inputType = getInputType(nestedNode);
+      if (inputType === supportedTypes.FIELDSET) {
+        processNode(nestedNode, formValues[name] || {}, getField(name, formFields).fields);
+      }
+    });
+  }
+  return {
+    required: requiredFields
+  };
+}
+function clearValuesIfNotVisible(fields, formValues) {
+  fields.forEach(({ isVisible = true, name, inputType, fields: nestedFields }) => {
+    if (!isVisible) {
+      formValues[name] = null;
+    }
+    if (inputType === supportedTypes.FIELDSET && nestedFields && formValues[name]) {
+      clearValuesIfNotVisible(nestedFields, formValues[name]);
+    }
+  });
+}
+function updateFieldsProperties(fields, formValues, jsonSchema) {
+  if (!jsonSchema?.properties) {
+    return;
+  }
+  processNode(jsonSchema, formValues, fields);
+  clearValuesIfNotVisible(fields, formValues);
+}
+var notNullOption = (opt) => opt.const !== null;
+function getFieldOptions(node, presentation) {
+  function convertToOptions(nodeOptions) {
+    return nodeOptions.filter(notNullOption).map(({ title, const: cons, ...item }) => ({
+      label: title,
+      value: cons,
+      ...item
+    }));
+  }
+  if (presentation.options) {
+    return presentation.options;
+  }
+  if (node.oneOf) {
+    return convertToOptions(node.oneOf);
+  }
+  if (node.items?.anyOf) {
+    return convertToOptions(node.items.anyOf);
+  }
+  return null;
+}
+function extractParametersFromNode(schemaNode) {
+  if (!schemaNode) {
+    return {};
+  }
+  const presentation = pickXKey(schemaNode, "presentation") ?? {};
+  const errorMessage = pickXKey(schemaNode, "errorMessage") ?? {};
+  const node = omit(schemaNode, ["x-jsf-presentation", "presentation"]);
+  const description = presentation?.description || node.description;
+  const statementDescription = containsHTML(presentation.statement?.description) ? wrapWithSpan(presentation.statement.description, { class: "jsf-statement" }) : presentation.statement?.description;
+  return omitBy(
+    {
+      label: node.title,
+      readOnly: node.readOnly,
+      ...node.deprecated && {
+        deprecated: {
+          description: presentation.deprecated?.description
+          // @TODO/@IDEA These might be useful down the road :thinking:
+          // version: presentation.deprecated.version, // e.g. "1.1"
+          // replacement: presentation.deprecated.replacement, // e.g. ['contract_duration_type']
+        }
+      },
+      pattern: node.pattern,
+      options: getFieldOptions(node, presentation),
+      items: node.items,
+      maxLength: node.maxLength,
+      minLength: node.minLength,
+      minimum: node.minimum,
+      maximum: node.maximum,
+      maxFileSize: node.maxFileSize,
+      // @deprecated in favor of presentation.maxFileSize
+      default: node.default,
+      // Checkboxes conditions
+      // — For checkboxes that only accept one value (string)
+      ...presentation?.inputType === "checkbox" && { checkboxValue: node.const },
+      // - For checkboxes with boolean value
+      ...presentation?.inputType === "checkbox" && node.type === "boolean" && {
+        // true is what describes this checkbox as a boolean, regardless if its required or not
+        checkboxValue: true
+      },
+      ...hasType(node.type, "array") && {
+        multiple: true
+      },
+      // Handle [name].presentation
+      ...presentation,
+      description: containsHTML(description) ? wrapWithSpan(description, {
+        class: "jsf-description"
+      }) : description,
+      extra: containsHTML(presentation.extra) ? wrapWithSpan(presentation.extra, { class: "jsf-extra" }) : presentation.extra,
+      statement: presentation.statement && {
+        ...presentation.statement,
+        description: statementDescription
+      },
+      // Support scoped conditions (fieldsets)
+      if: node.if,
+      then: node.then,
+      else: node.else,
+      anyOf: node.anyOf,
+      allOf: node.allOf,
+      errorMessage
+    },
+    isNil
+  );
+}
+function yupToFormErrors(yupError) {
+  if (!yupError) {
+    return yupError;
+  }
+  const errors = {};
+  if (yupError.inner) {
+    if (yupError.inner.length === 0) {
+      return set(errors, yupError.path, yupError.message);
+    }
+    yupError.inner.forEach((err) => {
+      if (!get2(errors, err.path)) {
+        set(errors, err.path, err.message);
+      }
+    });
+  }
+  return errors;
+}
+var handleValuesChange = (fields, jsonSchema, config) => (values) => {
+  updateFieldsProperties(fields, values, jsonSchema);
+  const lazySchema = lazy(() => buildCompleteYupSchema(fields, config));
+  let errors;
+  try {
+    lazySchema.validateSync(values, {
+      abortEarly: false
+    });
+  } catch (err) {
+    if (err.name === "ValidationError") {
+      errors = err;
+    } else {
+      console.warn(`Warning: An unhandled error was caught during validationSchema`, err);
+    }
+  }
+  return {
+    yupError: errors,
+    formErrors: yupToFormErrors(errors)
+  };
+};
+
+// src/calculateConditionalProperties.js
+function isFieldRequired(node, inputName) {
+  if (node?.required) {
+    return node.required.includes(inputName);
+  }
+  return false;
+}
+function rebuildInnerFieldsRequiredProperty(fields, property) {
+  if (property?.properties) {
+    return fields.map((field) => {
+      if (field.fields) {
+        return {
+          ...field,
+          fields: rebuildInnerFieldsRequiredProperty(field.fields, property.properties[field.name])
+        };
+      }
+      return {
+        ...field,
+        required: isFieldRequired(property, field.name)
+      };
+    });
+  }
+  return fields.map((field) => ({
+    ...field,
+    required: isFieldRequired(property, field.name)
+  }));
+}
+function calculateConditionalProperties(fieldParams, customProperties) {
+  return (isRequired, conditionBranch) => {
+    const conditionalProperty = conditionBranch?.properties?.[fieldParams.name];
+    if (conditionalProperty) {
+      const presentation = pickXKey(conditionalProperty, "presentation") ?? {};
+      const fieldDescription = getFieldDescription(conditionalProperty, customProperties);
+      const newFieldParams = extractParametersFromNode({
+        ...conditionalProperty,
+        ...fieldDescription
+      });
+      let fieldSetFields;
+      if (fieldParams.inputType === supportedTypes.FIELDSET) {
+        fieldSetFields = rebuildInnerFieldsRequiredProperty(
+          fieldParams.fields,
+          conditionalProperty
+        );
+        newFieldParams.fields = fieldSetFields;
+      }
+      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
+        })
+      };
+      return omit2(merge2(base, presentation, newFieldParams), ["inputType"]);
+    }
+    const isVisible = isRequired;
+    return {
+      isVisible,
+      required: isRequired,
+      schema: buildYupSchema({
+        ...fieldParams,
+        ...extractParametersFromNode(conditionBranch),
+        required: isRequired
+      })
+    };
+  };
+}
+
+// src/calculateCustomValidationProperties.js
+import inRange from "lodash/inRange";
+import isFunction2 from "lodash/isFunction";
+import isNil2 from "lodash/isNil";
+import isObject from "lodash/isObject";
+import mapValues from "lodash/mapValues";
+import pick from "lodash/pick";
+var SUPPORTED_CUSTOM_VALIDATION_FIELD_PARAMS = ["minimum", "maximum"];
+var isCustomValidationAllowed = (fieldParams) => (customValidation, customValidationKey) => {
+  if (isNil2(customValidation)) {
+    return false;
+  }
+  const { minimum, maximum } = fieldParams;
+  const isAllowed = inRange(
+    customValidation,
+    minimum ?? -Infinity,
+    maximum ? maximum + 1 : Infinity
+  );
+  if (!isAllowed) {
+    const errorMessage = `Custom validation for ${fieldParams.name} is not allowed because ${customValidationKey}:${customValidation} is less strict than the original range: ${minimum} to ${maximum}`;
+    if (true) {
+      throw new Error(errorMessage);
+    } else {
+      console.warn(errorMessage);
+    }
+  }
+  return isAllowed;
+};
+function calculateCustomValidationProperties(fieldParams, customProperties) {
+  return (isRequired, conditionBranch, formValues) => {
+    const params = { ...fieldParams, ...conditionBranch?.properties?.[fieldParams.name] };
+    const presentation = pickXKey(params, "presentation") ?? {};
+    const supportedParams = pick(customProperties, SUPPORTED_CUSTOM_VALIDATION_FIELD_PARAMS);
+    const checkIfAllowed = isCustomValidationAllowed(params);
+    const customErrorMessages = [];
+    const fieldParamsWithNewValidation = mapValues(
+      supportedParams,
+      (customValidationValue, customValidationKey) => {
+        const originalValidation = params[customValidationKey];
+        const customValidation = isFunction2(customValidationValue) ? customValidationValue(formValues, params) : customValidationValue;
+        if (isObject(customValidation)) {
+          if (checkIfAllowed(customValidation[customValidationKey], customValidationKey)) {
+            customErrorMessages.push(pickXKey(customValidation, "errorMessage"));
+            return customValidation[customValidationKey];
+          }
+          return originalValidation;
+        }
+        return checkIfAllowed(customValidation, customValidationKey) ? customValidation : originalValidation;
+      }
+    );
+    const errorMessage = Object.assign({ ...params.errorMessage }, ...customErrorMessages);
+    return {
+      ...params,
+      ...fieldParamsWithNewValidation,
+      type: presentation?.inputType || params.inputType,
+      errorMessage,
+      required: isRequired,
+      schema: buildYupSchema({
+        ...params,
+        ...fieldParamsWithNewValidation,
+        errorMessage,
+        required: isRequired
+      })
+    };
+  };
+}
+
+// src/createHeadlessForm.js
+function sortByOrderOrPosition(a, b, order) {
+  if (order) {
+    return order.indexOf(a.name) - order.indexOf(b.name);
+  }
+  return a.position - b.position;
+}
+function removeInvalidAttributes(fields) {
+  return omit3(fields, ["items", "maxFileSize", "isDynamic"]);
+}
+function buildFieldParameters(name, fieldProperties, required = [], config = {}) {
+  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}`, {})
+    });
+  }
+  const result = {
+    name,
+    inputType,
+    jsonType: fieldProperties.type,
+    type: inputType,
+    // @deprecated in favor of inputType,
+    required: required?.includes(name) ?? false,
+    fields,
+    position,
+    ...extractParametersFromNode(fieldProperties)
+  };
+  return omitBy2(result, isNil3);
+}
+function convertJSONSchemaPropertiesToFieldParameters({ properties, required, "x-jsf-order": order }, config = {}) {
+  const sortFields = (a, b) => sortByOrderOrPosition(a, b, order);
+  return Object.entries(properties).filter(([, value]) => typeof value === "object").map(([key, value]) => buildFieldParameters(key, value, required, config)).sort(sortFields).map(({ position, ...fieldParams }) => fieldParams);
+}
+function applyFieldsDependencies(fieldsParameters, node) {
+  if (node?.then) {
+    fieldsParameters.filter(
+      ({ name }) => node.then?.properties?.[name] || node.then?.required?.includes(name) || node.else?.properties?.[name] || node.else?.required?.includes(name)
+    ).forEach((property) => {
+      property.isDynamic = true;
+    });
+    applyFieldsDependencies(fieldsParameters, node.then);
+  }
+  if (node?.anyOf) {
+    fieldsParameters.filter(({ name }) => node.anyOf.some(({ required }) => required?.includes(name))).forEach((property) => {
+      property.isDynamic = true;
+    });
+    applyFieldsDependencies(fieldsParameters, node.then);
+  }
+  if (node?.allOf) {
+    node.allOf.forEach((condition) => {
+      applyFieldsDependencies(fieldsParameters, condition);
+    });
+  }
+}
+function getCustomPropertiesForField(fieldParams, config) {
+  return config?.customProperties?.[fieldParams.name];
+}
+function getComposeFunctionForField(fieldParams, hasCustomizations) {
+  const composeFn = inputTypeMap[fieldParams.inputType] || _composeFieldArbitraryClosure(fieldParams.inputType);
+  if (hasCustomizations) {
+    return _composeFieldCustomClosure(composeFn);
+  }
+  return composeFn;
+}
+function buildField(fieldParams, config, scopedJsonSchema) {
+  const customProperties = getCustomPropertiesForField(fieldParams, config);
+  const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
+  const yupSchema = buildYupSchema(fieldParams, config);
+  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties);
+  const calculateCustomValidationPropertiesClosure = calculateCustomValidationProperties(
+    fieldParams,
+    customProperties
+  );
+  const hasCustomValidations = !!customProperties && size(pick2(customProperties, SUPPORTED_CUSTOM_VALIDATION_FIELD_PARAMS)) > 0;
+  const finalFieldParams = {
+    // invalid attribute cleanup
+    ...removeInvalidAttributes(fieldParams),
+    // calculateConditionalProperties function if needed
+    ...!!calculateConditionalFieldsClosure && {
+      calculateConditionalProperties: calculateConditionalFieldsClosure
+    },
+    // calculateCustomValidationProperties function if needed
+    ...hasCustomValidations && {
+      calculateCustomValidationProperties: calculateCustomValidationPropertiesClosure
+    },
+    // field customization properties
+    ...customProperties && { fieldCustomization: customProperties },
+    // base schema
+    schema: yupSchema(),
+    scopedJsonSchema
+  };
+  return composeFn(finalFieldParams);
+}
+function getFieldsFromJSONSchema(scopedJsonSchema, config) {
+  if (!scopedJsonSchema) {
+    return [];
+  }
+  const fieldParamsList = convertJSONSchemaPropertiesToFieldParameters(scopedJsonSchema, config);
+  applyFieldsDependencies(fieldParamsList, scopedJsonSchema);
+  const fields = [];
+  fieldParamsList.forEach((fieldParams) => {
+    if (fieldParams.inputType === "group-array") {
+      const groupArrayItems = convertJSONSchemaPropertiesToFieldParameters(fieldParams.items);
+      const groupArrayFields = groupArrayItems.map((groupArrayItem) => {
+        groupArrayItem.nameKey = groupArrayItem.name;
+        const customProperties = null;
+        const composeFn = getComposeFunctionForField(groupArrayItem, !!customProperties);
+        return composeFn(groupArrayItem);
+      });
+      fieldParams.nameKey = fieldParams.name;
+      fieldParams.nthFieldGroup = {
+        name: fieldParams.name,
+        label: fieldParams.label,
+        description: fieldParams.description,
+        fields: () => groupArrayFields,
+        addFieldText: fieldParams.addFieldText
+      };
+      buildField(fieldParams, config, scopedJsonSchema).forEach((groupField) => {
+        fields.push(groupField);
+      });
+    } else {
+      fields.push(buildField(fieldParams, config, scopedJsonSchema));
+    }
+  });
+  return fields;
+}
+function createHeadlessForm(jsonSchema, customConfig = {}) {
+  const config = {
+    strictInputType: true,
+    ...customConfig
+  };
+  try {
+    const fields = getFieldsFromJSONSchema(jsonSchema, config);
+    const handleValidation = handleValuesChange(fields, jsonSchema, config);
+    updateFieldsProperties(fields, getPrefillValues(fields, config.initialValues), jsonSchema);
+    return {
+      fields,
+      handleValidation,
+      isError: false
+    };
+  } catch (error) {
+    console.error("JSON Schema invalid!", error);
+    return {
+      fields: [],
+      isError: true,
+      error
+    };
+  }
+}
+export {
+  createHeadlessForm
+};