@rjsf/utils 6.5.3 → 6.6.0

package/dist/index.cjs

@@ -132,6 +132,7 @@ __export(index_exports, {
   isObject: () => isObject,
   isRootSchema: () => isRootSchema,
   isSelect: () => isSelect,
+  isValueEmpty: () => isValueEmpty,
   labelValue: () => labelValue,
   localToUTC: () => localToUTC,
   lookupFromFormContext: () => lookupFromFormContext,
@@ -146,6 +147,7 @@ __export(index_exports, {
   pad: () => pad,
   parseDateString: () => parseDateString,
   rangeSpec: () => rangeSpec,
+  relaxOptionsForScoring: () => relaxOptionsForScoring,
   removeOptionalEmptyObjects: () => removeOptionalEmptyObjects,
   replaceStringParameters: () => replaceStringParameters,
   resolveUiSchema: () => resolveUiSchema,
@@ -320,6 +322,9 @@ function createErrorHandler(formData) {
   return handler;
 }
 
+// src/createSchemaUtils.ts
+var import_get17 = __toESM(require("lodash/get"), 1);
+
 // src/deepEquals.ts
 var import_fast_equals = require("fast-equals");
 var deepEquals = (0, import_fast_equals.createCustomEqual)({
@@ -332,32 +337,13 @@ var deepEquals = (0, import_fast_equals.createCustomEqual)({
 });
 var deepEquals_default = deepEquals;
 
-// src/schema/findFieldInSchema.ts
-var import_get8 = __toESM(require("lodash/get"), 1);
-var import_has3 = __toESM(require("lodash/has"), 1);
-
-// src/schema/findSelectedOptionInXxxOf.ts
-var import_get6 = __toESM(require("lodash/get"), 1);
-
-// src/schema/retrieveSchema.ts
-var import_get5 = __toESM(require("lodash/get"), 1);
-var import_set = __toESM(require("lodash/set"), 1);
-var import_times = __toESM(require("lodash/times"), 1);
-var import_transform = __toESM(require("lodash/transform"), 1);
-var import_merge = __toESM(require("lodash/merge"), 1);
-var import_flattenDeep = __toESM(require("lodash/flattenDeep"), 1);
-var import_uniq = __toESM(require("lodash/uniq"), 1);
-var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
-var import_json_schema_merge = require("@x0k/json-schema-merge");
-var import_array = require("@x0k/json-schema-merge/lib/array");
-
 // src/findSchemaDefinition.ts
-var import_jsonpointer = __toESM(require("jsonpointer"), 1);
-var import_omit = __toESM(require("lodash/omit"), 1);
-var import_isObject3 = __toESM(require("lodash/isObject"), 1);
-var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
 var import_fast_uri = __toESM(require("fast-uri"), 1);
+var import_jsonpointer = __toESM(require("jsonpointer"), 1);
 var import_get = __toESM(require("lodash/get"), 1);
+var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
+var import_isObject3 = __toESM(require("lodash/isObject"), 1);
+var import_omit = __toESM(require("lodash/omit"), 1);
 function findEmbeddedSchemaRecursive(schema, ref) {
   if (ID_KEY in schema && import_fast_uri.default.equal(schema[ID_KEY], ref)) {
     return schema;
@@ -458,6 +444,13 @@ function findSchemaDefinition($ref, rootSchema = {}, baseURI = (0, import_get.de
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }
 
+// src/schema/findFieldInSchema.ts
+var import_get8 = __toESM(require("lodash/get"), 1);
+var import_has3 = __toESM(require("lodash/has"), 1);
+
+// src/schema/findSelectedOptionInXxxOf.ts
+var import_get6 = __toESM(require("lodash/get"), 1);
+
 // src/getDiscriminatorFieldFromSchema.ts
 var import_get2 = __toESM(require("lodash/get"), 1);
 var import_isString = __toESM(require("lodash/isString"), 1);
@@ -472,6 +465,16 @@ function getDiscriminatorFieldFromSchema(schema) {
   return discriminator;
 }
 
+// src/schema/retrieveSchema.ts
+var import_flattenDeep = __toESM(require("lodash/flattenDeep"), 1);
+var import_get5 = __toESM(require("lodash/get"), 1);
+var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
+var import_merge = __toESM(require("lodash/merge"), 1);
+var import_set = __toESM(require("lodash/set"), 1);
+var import_times = __toESM(require("lodash/times"), 1);
+var import_transform = __toESM(require("lodash/transform"), 1);
+var import_uniq = __toESM(require("lodash/uniq"), 1);
+
 // src/guessType.ts
 function guessType(value) {
   if (Array.isArray(value)) {
@@ -613,6 +616,16 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
   return 0;
 }
 
+// src/schema/shallowAllOfMerge.ts
+var import_json_schema_merge = require("@x0k/json-schema-merge");
+var import_array = require("@x0k/json-schema-merge/lib/array");
+var { compareSchemaDefinitions, compareSchemaValues } = (0, import_json_schema_merge.createComparator)();
+var { mergeArrayOfSchemaDefinitions } = (0, import_json_schema_merge.createMerger)({
+  intersectJson: (0, import_array.createIntersector)(compareSchemaValues),
+  deduplicateJsonSchemaDef: (0, import_array.createDeduplicator)(compareSchemaDefinitions)
+});
+var shallowAllOfMerge_default = (0, import_json_schema_merge.createShallowAllOfMerge)(mergeArrayOfSchemaDefinitions);
+
 // src/schema/retrieveSchema.ts
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs = false) {
   return retrieveSchemaInternal(
@@ -899,14 +912,8 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
   });
   return schema;
 }
-var { compareSchemaDefinitions, compareSchemaValues } = (0, import_json_schema_merge.createComparator)();
-var { mergeArrayOfSchemaDefinitions } = (0, import_json_schema_merge.createMerger)({
-  intersectJson: (0, import_array.createIntersector)(compareSchemaValues),
-  deduplicateJsonSchemaDef: (0, import_array.createDeduplicator)(compareSchemaDefinitions)
-});
-var shallowAllOfMerge = (0, import_json_schema_merge.createShallowAllOfMerge)(mergeArrayOfSchemaDefinitions);
 function mergeAllOf(schema) {
-  return shallowAllOfMerge(schema);
+  return shallowAllOfMerge_default(schema);
 }
 function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
   if (!isObject(schema)) {
@@ -1013,12 +1020,23 @@ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranch
     });
     const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
     if (expandAllBranches) {
+      const relaxed = relaxOptionsForScoring(anyOrOneOf, false, rootSchema);
+      getFirstMatchingOption(validator, formData, relaxed, rootSchema, discriminator);
       return anyOrOneOf.map((item) => mergeSchemas(remaining, item));
     }
     schema = mergeSchemas(remaining, anyOrOneOf[option]);
   }
   return [schema];
 }
+function relaxOptionsForScoring(options, resolveRefs = false, rootSchema) {
+  return options.map((d) => {
+    if (!isObject(d)) {
+      return d ? {} : { not: {} };
+    }
+    const schema = resolveRefs && rootSchema ? resolveAllReferences(d, rootSchema, []) : d;
+    return schema.additionalProperties === false ? { ...schema, additionalProperties: true } : schema;
+  });
+}
 function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   const { dependencies, ...remainingSchema } = schema;
   const resolvedSchemas = resolveAnyOrOneOfSchemas(
@@ -1309,10 +1327,6 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
   return { field, isRequired };
 }
 
-// src/schema/getDefaultFormState.ts
-var import_get12 = __toESM(require("lodash/get"), 1);
-var import_isEmpty4 = __toESM(require("lodash/isEmpty"), 1);
-
 // src/schema/getClosestMatchingOption.ts
 var import_get9 = __toESM(require("lodash/get"), 1);
 var import_has4 = __toESM(require("lodash/has"), 1);
@@ -1437,6 +1451,23 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
   return bestIndex;
 }
 
+// src/schema/getDefaultFormState.ts
+var import_get12 = __toESM(require("lodash/get"), 1);
+var import_isEmpty4 = __toESM(require("lodash/isEmpty"), 1);
+
+// src/constIsAjvDataReference.ts
+var import_isString3 = __toESM(require("lodash/isString"), 1);
+function constIsAjvDataReference(schema) {
+  const schemaConst = schema[CONST_KEY];
+  const schemaType = getSchemaType(schema);
+  return isObject(schemaConst) && (0, import_isString3.default)(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
+}
+
+// src/isConstant.ts
+function isConstant(schema) {
+  return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
+}
+
 // src/isFixedItems.ts
 function isFixedItems(schema) {
   return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
@@ -1529,40 +1560,6 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
   );
 }
 
-// src/isConstant.ts
-function isConstant(schema) {
-  return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
-}
-
-// src/schema/isSelect.ts
-function isSelect(validator, theSchema, rootSchema = {}, experimental_customMergeAllOf) {
-  const schema = retrieveSchema(validator, theSchema, rootSchema, void 0, experimental_customMergeAllOf);
-  const altSchemas = schema.oneOf || schema.anyOf;
-  if (Array.isArray(schema.enum)) {
-    return true;
-  }
-  if (Array.isArray(altSchemas)) {
-    return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
-  }
-  return false;
-}
-
-// src/schema/isMultiSelect.ts
-function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
-  if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
-    return false;
-  }
-  return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
-}
-
-// src/constIsAjvDataReference.ts
-var import_isString3 = __toESM(require("lodash/isString"), 1);
-function constIsAjvDataReference(schema) {
-  const schemaConst = schema[CONST_KEY];
-  const schemaType = getSchemaType(schema);
-  return isObject(schemaConst) && (0, import_isString3.default)(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
-}
-
 // src/optionsList.ts
 var import_get11 = __toESM(require("lodash/get"), 1);
 
@@ -1643,6 +1640,27 @@ function optionsList(schema, uiSchema) {
   });
 }
 
+// src/schema/isSelect.ts
+function isSelect(validator, theSchema, rootSchema = {}, experimental_customMergeAllOf) {
+  const schema = retrieveSchema(validator, theSchema, rootSchema, void 0, experimental_customMergeAllOf);
+  const altSchemas = schema.oneOf || schema.anyOf;
+  if (Array.isArray(schema.enum)) {
+    return true;
+  }
+  if (Array.isArray(altSchemas)) {
+    return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
+  }
+  return false;
+}
+
+// src/schema/isMultiSelect.ts
+function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
+  if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
+    return false;
+  }
+  return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
+}
+
 // src/schema/getDefaultFormState.ts
 var PRIMITIVE_TYPES = ["string", "number", "integer", "boolean", "null"];
 function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, idx = -1) {
@@ -2002,14 +2020,11 @@ function getArrayDefaults(validator, rawSchema, {
       defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
     }
   }
-  const hasConst = isObject(schema) && CONST_KEY in schema && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
-  if (hasConst === false) {
-    if (neverPopulate) {
-      return defaults ?? emptyDefault;
-    }
-    if (ignoreMinItemsFlagSet && !required) {
-      return defaults ? defaults : void 0;
-    }
+  if (neverPopulate) {
+    return defaults ?? emptyDefault;
+  }
+  if (ignoreMinItemsFlagSet && !required) {
+    return defaults ? defaults : void 0;
   }
   let arrayDefault;
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
@@ -2139,210 +2154,269 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-var import_pick = __toESM(require("lodash/pick"), 1);
-var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
-var import_get15 = __toESM(require("lodash/get"), 1);
-
-// src/schema/toPathSchema.ts
 var import_get14 = __toESM(require("lodash/get"), 1);
-var import_isObject11 = __toESM(require("lodash/isObject"), 1);
-var import_set2 = __toESM(require("lodash/set"), 1);
-function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
-  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
-    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals_default(item, _schema));
-    if (sameSchemaIndex === -1) {
-      return toPathSchemaInternal(
-        validator,
-        _schema,
-        name,
-        rootSchema,
-        formData,
-        _recurseList.concat(_schema),
-        experimental_customMergeAllOf
-      );
-    }
+var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
+var import_isNil2 = __toESM(require("lodash/isNil"), 1);
+var import_pick = __toESM(require("lodash/pick"), 1);
+function getUsedFormData(formData, fields) {
+  if (fields.length === 0 && typeof formData !== "object") {
+    return formData;
   }
-  let pathSchema = {
-    [NAME_KEY]: name.replace(/^\./, "")
+  const data = (0, import_pick.default)(formData, fields);
+  if (Array.isArray(formData)) {
+    return Object.keys(data).map((key) => data[key]);
+  }
+  return data;
+}
+function getFieldNames(pathSchema, formData) {
+  const formValueHasData = (value, isLeaf) => typeof value !== "object" || (0, import_isEmpty5.default)(value) || isLeaf && !(0, import_isEmpty5.default)(value);
+  const getAllPaths = (_obj, acc = [], paths = [[]]) => {
+    const objKeys = Object.keys(_obj);
+    objKeys.forEach((key) => {
+      const data = _obj[key];
+      if (typeof data === "object") {
+        const newPaths = paths.map((path) => [...path, key]);
+        if (data[RJSF_ADDITIONAL_PROPERTIES_FLAG] && data[NAME_KEY] !== "") {
+          acc.push(data[NAME_KEY]);
+        } else {
+          getAllPaths(data, acc, newPaths);
+        }
+      } else if (key === NAME_KEY && data !== "") {
+        paths.forEach((path) => {
+          const formValue = (0, import_get14.default)(formData, path);
+          const isLeaf = objKeys.length === 1;
+          if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
+            acc.push(path);
+          }
+        });
+      }
+    });
+    return acc;
   };
-  if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
-    const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
-    const discriminator = getDiscriminatorFieldFromSchema(schema);
-    const index = getClosestMatchingOption(
+  return getAllPaths(pathSchema);
+}
+function isValueEmpty(value) {
+  if ((0, import_isNil2.default)(value) || value === "") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (isObject(value)) {
+    return Object.values(value).every(isValueEmpty);
+  }
+  return false;
+}
+function doMergeAllOf(schema, experimental_customMergeAllOf) {
+  return experimental_customMergeAllOf ? experimental_customMergeAllOf(schema) : shallowAllOfMerge_default(schema);
+}
+function omitExtraData(validator, schema, rootSchema = {}, formData, experimental_customMergeAllOf) {
+  function isObjectValue(value) {
+    return isObject(value);
+  }
+  function isSchemaObj(schemaDef) {
+    return isObject(schemaDef);
+  }
+  function handleObject(schema2, source, target) {
+    const { properties, additionalProperties, patternProperties, propertyNames } = schema2;
+    const requiredSet = new Set(schema2.required ?? []);
+    function setProperty(key, schemaDef, value, required = false) {
+      const v = omit3(schemaDef, value, target[key]);
+      if (!required && isObject(v)) {
+        let sd = isSchemaObj(schemaDef) ? schemaDef : {};
+        if (sd.$ref !== void 0) {
+          sd = findSchemaDefinition(sd.$ref, rootSchema);
+        }
+        const innerRequired = new Set(sd.required ?? []);
+        const shouldDrop = Object.entries(v).every(
+          ([k, val]) => !innerRequired.has(k) && isValueEmpty(val)
+        );
+        if (shouldDrop) {
+          return;
+        }
+      }
+      if (v !== void 0) {
+        target[key] = v;
+      }
+    }
+    if (properties !== void 0) {
+      for (const [key, schemaDef] of Object.entries(properties)) {
+        setProperty(key, schemaDef, source[key], requiredSet.has(key));
+      }
+    }
+    let patternPropertiesRest;
+    if (patternProperties !== void 0) {
+      patternPropertiesRest = [];
+      const patterns = Object.entries(patternProperties).map(([pattern, schemaDef]) => [
+        new RegExp(pattern),
+        schemaDef
+      ]);
+      const knownProperties = new Set(Object.keys(properties ?? {}));
+      for (const [key, value] of Object.entries(source)) {
+        if (knownProperties.has(key)) {
+          continue;
+        }
+        const matched = patterns.find(([re]) => re.test(key));
+        if (matched === void 0) {
+          patternPropertiesRest.push(key);
+          continue;
+        }
+        setProperty(key, matched[1], value);
+      }
+    }
+    if (additionalProperties !== void 0 && additionalProperties !== false) {
+      const addlSchema = additionalProperties;
+      if (patternPropertiesRest !== void 0) {
+        for (const key of patternPropertiesRest) {
+          setProperty(key, addlSchema, source[key]);
+        }
+      } else {
+        const knownProperties = new Set(Object.keys(properties ?? {}));
+        for (const [key, value] of Object.entries(source)) {
+          if (knownProperties.has(key)) {
+            continue;
+          }
+          setProperty(key, addlSchema, value);
+        }
+      }
+    }
+    if (propertyNames !== void 0) {
+      for (const [key, value] of Object.entries(source)) {
+        target[key] = value;
+      }
+    }
+    return target;
+  }
+  function handleArray(schema2, source, target) {
+    const { items, additionalItems } = schema2;
+    if (items !== void 0) {
+      if (Array.isArray(items)) {
+        for (let i = 0; i < items.length; i++) {
+          target.push(omit3(items[i], source[i]));
+        }
+      } else {
+        for (let i = 0; i < source.length; i++) {
+          target.push(omit3(items, source[i]));
+        }
+      }
+    }
+    if (additionalItems) {
+      for (let i = target.length; i < source.length; i++) {
+        target.push(omit3(additionalItems, source[i]));
+      }
+    }
+    return target;
+  }
+  function handleConditions(schema2, source, target) {
+    const { if: condition, then, else: otherwise } = schema2;
+    if (condition === void 0) {
+      return target;
+    }
+    const isThenBranch = isSchemaObj(condition) ? validator.isValid(condition, source, rootSchema) : condition;
+    const branch = isThenBranch ? then : otherwise;
+    return branch === void 0 ? target : omit3(branch, source, target);
+  }
+  function handleOneOf(oneOf, schema2, source, target) {
+    if (!Array.isArray(oneOf) || isSelect(validator, schema2, rootSchema, experimental_customMergeAllOf)) {
+      return target;
+    }
+    const scoringOptions = relaxOptionsForScoring(oneOf, true, rootSchema);
+    const bestIndex = getClosestMatchingOption(
       validator,
       rootSchema,
-      formData,
-      xxxOf,
+      source,
+      scoringOptions,
       0,
-      discriminator,
+      getDiscriminatorFieldFromSchema(schema2),
       experimental_customMergeAllOf
     );
-    const _schema = xxxOf[index];
-    pathSchema = {
-      ...pathSchema,
-      ...toPathSchemaInternal(
-        validator,
-        _schema,
-        name,
-        rootSchema,
-        formData,
-        _recurseList,
-        experimental_customMergeAllOf
-      )
-    };
-  }
-  if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    (0, import_set2.default)(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-    const additionalSchema = (0, import_isObject11.default)(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = (0, import_get14.default)(schema, PROPERTIES_KEY, {});
-    for (const key of Object.keys(formData ?? {})) {
-      if (!(key in definedProperties)) {
-        pathSchema[key] = toPathSchemaInternal(
-          validator,
-          additionalSchema,
-          `${name}.${key}`,
-          rootSchema,
-          (0, import_get14.default)(formData, [key]),
-          _recurseList,
-          experimental_customMergeAllOf
-        );
+    const winning = oneOf[bestIndex];
+    const resolved = isObject(winning) ? resolveAllReferences(winning, rootSchema, []) : scoringOptions[bestIndex];
+    return omit3(resolved, source, target);
+  }
+  function handleAnyOf(schema2, source, target) {
+    const { anyOf } = schema2;
+    if (!Array.isArray(anyOf)) {
+      return target;
+    }
+    if (source === void 0 || Array.isArray(source) && source.length === 0 || isObject(source) && Object.keys(source).length === 0) {
+      for (const branch of anyOf) {
+        target = omit3(branch, source, target);
       }
+      return target;
     }
+    return handleOneOf(anyOf, schema2, source, target);
   }
-  if (ITEMS_KEY in schema && Array.isArray(formData)) {
-    const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
-    if (Array.isArray(schemaItems)) {
-      formData.forEach((element, i) => {
-        if (schemaItems[i]) {
-          pathSchema[i] = toPathSchemaInternal(
-            validator,
-            schemaItems[i],
-            `${name}.${i}`,
-            rootSchema,
-            element,
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        } else if (schemaAdditionalItems) {
-          pathSchema[i] = toPathSchemaInternal(
-            validator,
-            schemaAdditionalItems,
-            `${name}.${i}`,
-            rootSchema,
-            element,
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        } else {
-          console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
-        }
-      });
-    } else {
-      formData.forEach((element, i) => {
-        pathSchema[i] = toPathSchemaInternal(
-          validator,
-          schemaItems,
-          `${name}.${i}`,
-          rootSchema,
-          element,
-          _recurseList,
-          experimental_customMergeAllOf
-        );
-      });
+  function handleDependencies(schema2, source, target) {
+    const { dependencies } = schema2;
+    if (dependencies === void 0 || !isObjectValue(source)) {
+      return target;
     }
-  } else if (PROPERTIES_KEY in schema) {
-    for (const property in schema.properties) {
-      const field = (0, import_get14.default)(schema, [PROPERTIES_KEY, property], {});
-      pathSchema[property] = toPathSchemaInternal(
-        validator,
-        field,
-        `${name}.${property}`,
-        rootSchema,
-        // It's possible that formData is not an object -- this can happen if an
-        // array item has just been added, but not populated with data yet
-        (0, import_get14.default)(formData, [property]),
-        _recurseList,
-        experimental_customMergeAllOf
-      );
+    for (const [key, deps] of Object.entries(dependencies)) {
+      if (!(key in source) || Array.isArray(deps)) {
+        continue;
+      }
+      target = omit3(deps, source, target);
     }
+    return target;
   }
-  return pathSchema;
-}
-function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
-  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
-}
-
-// src/schema/omitExtraData.ts
-function getUsedFormData(formData, fields) {
-  if (fields.length === 0 && typeof formData !== "object") {
-    return formData;
-  }
-  const data = (0, import_pick.default)(formData, fields);
-  if (Array.isArray(formData)) {
-    return Object.keys(data).map((key) => data[key]);
-  }
-  return data;
-}
-function getFieldNames(pathSchema, formData) {
-  const formValueHasData = (value, isLeaf) => typeof value !== "object" || (0, import_isEmpty5.default)(value) || isLeaf && !(0, import_isEmpty5.default)(value);
-  const getAllPaths = (_obj, acc = [], paths = [[]]) => {
-    const objKeys = Object.keys(_obj);
-    objKeys.forEach((key) => {
-      const data = _obj[key];
-      if (typeof data === "object") {
-        const newPaths = paths.map((path) => [...path, key]);
-        if (data[RJSF_ADDITIONAL_PROPERTIES_FLAG] && data[NAME_KEY] !== "") {
-          acc.push(data[NAME_KEY]);
-        } else {
-          getAllPaths(data, acc, newPaths);
-        }
-      } else if (key === NAME_KEY && data !== "") {
-        paths.forEach((path) => {
-          const formValue = (0, import_get15.default)(formData, path);
-          const isLeaf = objKeys.length === 1;
-          if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
-            acc.push(path);
-          }
-        });
+  function omit3(schemaDef, source, target) {
+    if (source === void 0 || schemaDef === false) {
+      return void 0;
+    }
+    if (schemaDef === true || (0, import_isEmpty5.default)(schemaDef)) {
+      return source;
+    }
+    let schema2 = schemaDef;
+    const { $ref: ref, allOf } = schema2;
+    if (ref !== void 0) {
+      return omit3(findSchemaDefinition(ref, rootSchema), source, target);
+    }
+    if (allOf) {
+      schema2 = doMergeAllOf(schema2, experimental_customMergeAllOf);
+    }
+    target = handleAnyOf(schema2, source, handleOneOf(schema2.oneOf, schema2, source, target));
+    const type = getSchemaType(schema2);
+    if (type === "object") {
+      if (!isObjectValue(source)) {
+        return void 0;
       }
-    });
-    return acc;
-  };
-  return getAllPaths(pathSchema);
-}
-function omitExtraData(validator, schema, rootSchema = {}, formData) {
-  const retrievedSchema = retrieveSchema(validator, schema, rootSchema, formData);
-  const pathSchema = toPathSchema(validator, retrievedSchema, "", rootSchema, formData);
-  const fieldNames = getFieldNames(pathSchema, formData);
-  const lodashFieldNames = fieldNames.map(
-    (fieldPaths) => Array.isArray(fieldPaths) ? fieldPaths.join(".") : fieldPaths
-  );
-  return getUsedFormData(formData, lodashFieldNames);
+      target = handleObject(schema2, source, isObjectValue(target) ? target : {});
+    } else if (type === "array") {
+      if (!Array.isArray(source)) {
+        return void 0;
+      }
+      target = handleArray(schema2, source, Array.isArray(target) ? target : []);
+    } else if (target === void 0) {
+      target = source;
+    }
+    return handleDependencies(schema2, source, handleConditions(schema2, source, target));
+  }
+  return omit3(schema, formData);
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-var import_get16 = __toESM(require("lodash/get"), 1);
+var import_get15 = __toESM(require("lodash/get"), 1);
 var import_has5 = __toESM(require("lodash/has"), 1);
-var NO_VALUE = Symbol("no Value");
+var NO_VALUE = /* @__PURE__ */ Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
   let newFormData;
   if ((0, import_has5.default)(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if ((0, import_has5.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get16.default)(oldSchema, PROPERTIES_KEY, {});
+      const properties = (0, import_get15.default)(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if ((0, import_has5.default)(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys((0, import_get16.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys((0, import_get15.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = (0, import_get16.default)(data, key);
-      let oldKeyedSchema = (0, import_get16.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get16.default)(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = (0, import_get15.default)(data, key);
+      let oldKeyedSchema = (0, import_get15.default)(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = (0, import_get15.default)(newSchema, [PROPERTIES_KEY, key], {});
       if ((0, import_has5.default)(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -2361,8 +2435,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = (0, import_get16.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get16.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = (0, import_get15.default)(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = (0, import_get15.default)(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if ((0, import_has5.default)(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -2380,17 +2454,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get16.default)(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = (0, import_get16.default)(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = (0, import_get15.default)(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = (0, import_get15.default)(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if ((0, import_get16.default)(newKeyedSchema, "readOnly") === true) {
+            } else if ((0, import_get15.default)(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get16.default)(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = (0, import_get16.default)(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = (0, import_get15.default)(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = (0, import_get15.default)(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -2402,9 +2476,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if ((0, import_get16.default)(oldSchema, "type") === "array" && (0, import_get16.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get16.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get16.default)(newSchema, "items");
+  } else if ((0, import_get15.default)(oldSchema, "type") === "array" && (0, import_get15.default)(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = (0, import_get15.default)(oldSchema, "items");
+    let newSchemaItems = (0, import_get15.default)(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if ((0, import_has5.default)(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -2424,10 +2498,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = (0, import_get16.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get16.default)(newSchemaItems, "type");
+      const oldSchemaType = (0, import_get15.default)(oldSchemaItems, "type");
+      const newSchemaType = (0, import_get15.default)(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get16.default)(newSchema, "maxItems", -1);
+        const maxItems = (0, import_get15.default)(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2454,8 +2528,137 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
+// src/schema/toPathSchema.ts
+var import_get16 = __toESM(require("lodash/get"), 1);
+var import_isObject12 = __toESM(require("lodash/isObject"), 1);
+var import_set2 = __toESM(require("lodash/set"), 1);
+function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
+  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals_default(item, _schema));
+    if (sameSchemaIndex === -1) {
+      return toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema),
+        experimental_customMergeAllOf
+      );
+    }
+  }
+  let pathSchema = {
+    [NAME_KEY]: name.replace(/^\./, "")
+  };
+  if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
+    const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
+    const discriminator = getDiscriminatorFieldFromSchema(schema);
+    const index = getClosestMatchingOption(
+      validator,
+      rootSchema,
+      formData,
+      xxxOf,
+      0,
+      discriminator,
+      experimental_customMergeAllOf
+    );
+    const _schema = xxxOf[index];
+    pathSchema = {
+      ...pathSchema,
+      ...toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList,
+        experimental_customMergeAllOf
+      )
+    };
+  }
+  if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
+    (0, import_set2.default)(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+    const additionalSchema = (0, import_isObject12.default)(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
+    const definedProperties = (0, import_get16.default)(schema, PROPERTIES_KEY, {});
+    for (const key of Object.keys(formData ?? {})) {
+      if (!(key in definedProperties)) {
+        pathSchema[key] = toPathSchemaInternal(
+          validator,
+          additionalSchema,
+          `${name}.${key}`,
+          rootSchema,
+          (0, import_get16.default)(formData, [key]),
+          _recurseList,
+          experimental_customMergeAllOf
+        );
+      }
+    }
+  }
+  if (ITEMS_KEY in schema && Array.isArray(formData)) {
+    const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
+    if (Array.isArray(schemaItems)) {
+      formData.forEach((element, i) => {
+        if (schemaItems[i]) {
+          pathSchema[i] = toPathSchemaInternal(
+            validator,
+            schemaItems[i],
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        } else if (schemaAdditionalItems) {
+          pathSchema[i] = toPathSchemaInternal(
+            validator,
+            schemaAdditionalItems,
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        } else {
+          console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
+        }
+      });
+    } else {
+      formData.forEach((element, i) => {
+        pathSchema[i] = toPathSchemaInternal(
+          validator,
+          schemaItems,
+          `${name}.${i}`,
+          rootSchema,
+          element,
+          _recurseList,
+          experimental_customMergeAllOf
+        );
+      });
+    }
+  } else if (PROPERTIES_KEY in schema) {
+    for (const property in schema.properties) {
+      const field = (0, import_get16.default)(schema, [PROPERTIES_KEY, property], {});
+      pathSchema[property] = toPathSchemaInternal(
+        validator,
+        field,
+        `${name}.${property}`,
+        rootSchema,
+        // It's possible that formData is not an object -- this can happen if an
+        // array item has just been added, but not populated with data yet
+        (0, import_get16.default)(formData, [property]),
+        _recurseList,
+        experimental_customMergeAllOf
+      );
+    }
+  }
+  return pathSchema;
+}
+function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
+}
+
 // src/createSchemaUtils.ts
-var import_get17 = __toESM(require("lodash/get"), 1);
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2795,31 +2998,6 @@ function dateRangeOptions(start, stop) {
   return options;
 }
 
-// src/shallowEquals.ts
-function shallowEquals(a, b) {
-  if (Object.is(a, b)) {
-    return true;
-  }
-  if (a == null || b == null) {
-    return false;
-  }
-  if (typeof a !== "object" || typeof b !== "object") {
-    return false;
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (let i = 0; i < keysA.length; i++) {
-    const key = keysA[i];
-    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // src/replaceStringParameters.ts
 function replaceStringParameters(inputString, params) {
   let output = inputString;
@@ -2836,9 +3014,28 @@ function replaceStringParameters(inputString, params) {
   return output;
 }
 
-// src/englishStringTranslator.ts
-function englishStringTranslator(stringToTranslate, params) {
-  return replaceStringParameters(stringToTranslate, params);
+// src/englishStringTranslator.ts
+function englishStringTranslator(stringToTranslate, params) {
+  return replaceStringParameters(stringToTranslate, params);
+}
+
+// src/enumOptionsValueForIndex.ts
+function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
+  if (Array.isArray(valueIndex)) {
+    return valueIndex.map((index2) => enumOptionsValueForIndex(index2, allEnumOptions)).filter((val) => val !== void 0);
+  }
+  const index = valueIndex === "" || valueIndex === null ? -1 : Number(valueIndex);
+  const option = allEnumOptions[index];
+  return option ? option.value : emptyValue;
+}
+
+// src/enumOptionsDeselectValue.ts
+function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
+  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  if (Array.isArray(selected)) {
+    return selected.filter((v) => !deepEquals_default(v, value));
+  }
+  return deepEquals_default(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
@@ -2871,14 +3068,17 @@ function enumOptionSelectedValue(value, enumOptions, multiple, format = "indexed
   return typeof indexes === "undefined" ? emptyValue : indexes;
 }
 
-// src/enumOptionsValueForIndex.ts
-function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
-  if (Array.isArray(valueIndex)) {
-    return valueIndex.map((index2) => enumOptionsValueForIndex(index2, allEnumOptions)).filter((val) => val !== emptyValue);
+// src/enumOptionsSelectValue.ts
+var import_isNil3 = __toESM(require("lodash/isNil"), 1);
+function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
+  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  if (!(0, import_isNil3.default)(value)) {
+    const index = allEnumOptions.findIndex((opt) => value === opt.value);
+    const all = allEnumOptions.map(({ value: val }) => val);
+    const updated = selected.slice(0, index).concat(value, selected.slice(index));
+    return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
   }
-  const index = valueIndex === "" || valueIndex === null ? -1 : Number(valueIndex);
-  const option = allEnumOptions[index];
-  return option ? option.value : emptyValue;
+  return selected;
 }
 
 // src/enumOptionValueDecoder.ts
@@ -2907,12 +3107,12 @@ function enumOptionValueDecoder(value, enumOptions, format = "indexed", emptyVal
 }
 
 // src/enumOptionValueEncoder.ts
-var import_isNil2 = __toESM(require("lodash/isNil"), 1);
+var import_isNil4 = __toESM(require("lodash/isNil"), 1);
 function enumOptionValueEncoder(value, index, format = "indexed") {
   if (format !== "realValue") {
     return String(index);
   }
-  if ((0, import_isNil2.default)(value)) {
+  if ((0, import_isNil4.default)(value)) {
     return "";
   }
   if (typeof value === "object") {
@@ -2921,28 +3121,6 @@ function enumOptionValueEncoder(value, index, format = "indexed") {
   return String(value);
 }
 
-// src/enumOptionsDeselectValue.ts
-function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
-  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (Array.isArray(selected)) {
-    return selected.filter((v) => !deepEquals_default(v, value));
-  }
-  return deepEquals_default(value, selected) ? void 0 : selected;
-}
-
-// src/enumOptionsSelectValue.ts
-var import_isNil3 = __toESM(require("lodash/isNil"), 1);
-function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
-  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!(0, import_isNil3.default)(value)) {
-    const index = allEnumOptions.findIndex((opt) => value === opt.value);
-    const all = allEnumOptions.map(({ value: val }) => val);
-    const updated = selected.slice(0, index).concat(value, selected.slice(index));
-    return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
-  }
-  return selected;
-}
-
 // src/ErrorSchemaBuilder.ts
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
 var import_get18 = __toESM(require("lodash/get"), 1);
@@ -3041,11 +3219,11 @@ var ErrorSchemaBuilder = class {
 };
 
 // src/getChangedFields.ts
+var import_difference = __toESM(require("lodash/difference"), 1);
+var import_get19 = __toESM(require("lodash/get"), 1);
+var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
 var import_keys = __toESM(require("lodash/keys"), 1);
 var import_pickBy = __toESM(require("lodash/pickBy"), 1);
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
-var import_get19 = __toESM(require("lodash/get"), 1);
-var import_difference = __toESM(require("lodash/difference"), 1);
 function getChangedFields(a, b) {
   const aIsPlainObject = (0, import_isPlainObject2.default)(a);
   const bIsPlainObject = (0, import_isPlainObject2.default)(b);
@@ -3187,7 +3365,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 var import_get20 = __toESM(require("lodash/get"), 1);
 var import_uniqueId = __toESM(require("lodash/uniqueId"), 1);
 function getTestIds() {
-  if (typeof process === "undefined" || (0, import_get20.default)(process, "env.NODE_ENV") !== "test") {
+  if ((0, import_get20.default)(globalThis, "process.env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3206,9 +3384,9 @@ function getTestIds() {
 
 // src/getWidget.tsx
 var import_react = require("react");
-var import_react_is = __toESM(require("react-is"), 1);
 var import_get21 = __toESM(require("lodash/get"), 1);
 var import_set4 = __toESM(require("lodash/set"), 1);
+var import_react_is = __toESM(require("react-is"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
   boolean: {
@@ -3369,11 +3547,11 @@ function optionalControlsId(id, element) {
 }
 
 // src/isFormDataAvailable.ts
-var import_isNil4 = __toESM(require("lodash/isNil"), 1);
 var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
-var import_isObject12 = __toESM(require("lodash/isObject"), 1);
+var import_isNil5 = __toESM(require("lodash/isNil"), 1);
+var import_isObject13 = __toESM(require("lodash/isObject"), 1);
 function isFormDataAvailable(formData) {
-  return !(0, import_isNil4.default)(formData) && (!(0, import_isObject12.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(formData));
+  return !(0, import_isNil5.default)(formData) && (!(0, import_isObject13.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(formData));
 }
 
 // src/isRootSchema.ts
@@ -3411,80 +3589,25 @@ function lookupFromFormContext(regOrFc, toLookup, fallback) {
   return (0, import_get22.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
-// src/removeOptionalEmptyObjects.ts
-var import_isNil5 = __toESM(require("lodash/isNil"), 1);
-function isValueEmpty(value) {
-  if ((0, import_isNil5.default)(value) || value === "") {
-    return true;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  if (isObject(value)) {
-    const obj = value;
-    const keys2 = Object.keys(obj);
-    return keys2.every((key) => isValueEmpty(obj[key]));
-  }
-  return false;
-}
-function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
-  if (!isObject(schema)) {
-    return formData;
-  }
-  const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
-  if (Array.isArray(formData)) {
-    const itemsSchema = resolvedSchema.items;
-    if (!itemsSchema) {
-      return formData;
-    }
-    let hasChanges = false;
-    const mapped = formData.map((item, index) => {
-      let itemSchema = itemsSchema;
-      if (Array.isArray(itemsSchema)) {
-        itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
-      }
-      const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
-      if (cleaned !== item) {
-        hasChanges = true;
-      }
-      return cleaned === void 0 ? {} : cleaned;
-    });
-    return hasChanges ? mapped : formData;
-  }
-  const { properties, required: requiredFields = [] } = resolvedSchema;
-  if (!isObject(formData) || !properties) {
-    return formData;
+// src/nameGenerators.ts
+var bracketNameGenerator = (path, idPrefix, isMultiValue) => {
+  if (!path || path.length === 0) {
+    return idPrefix;
   }
-  const result = {};
-  const data = formData;
-  let hasAnyValue = false;
-  for (const key of Object.keys(data)) {
-    const value = data[key];
-    const propertySchema = properties[key] || {};
-    const isRequired = requiredFields.includes(key);
-    const isObj = isObject(value);
-    const isArr = Array.isArray(value);
-    if ((isObj || isArr) && properties[key]) {
-      const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
-      if (!isRequired && isValueEmpty(cleaned)) {
-        continue;
-      }
-      result[key] = cleaned;
-      hasAnyValue = true;
-    } else if (!isRequired && isValueEmpty(value) && properties[key]) {
-      continue;
-    } else {
-      result[key] = value;
-      if (!isValueEmpty(value)) {
-        hasAnyValue = true;
-      }
+  const baseName = path.reduce((acc, pathUnit, index) => {
+    if (index === 0) {
+      return `${idPrefix}[${String(pathUnit)}]`;
     }
+    return `${acc}[${String(pathUnit)}]`;
+  }, "");
+  return isMultiValue ? `${baseName}[]` : baseName;
+};
+var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
+  if (!path || path.length === 0) {
+    return idPrefix;
   }
-  if (!hasAnyValue && Object.keys(result).length === 0) {
-    return void 0;
-  }
-  return result;
-}
+  return `${idPrefix}.${path.map(String).join(".")}`;
+};
 
 // src/orderProperties.ts
 function orderProperties(properties, order) {
@@ -3542,6 +3665,64 @@ function parseDateString(dateString, includeTime = true) {
   };
 }
 
+// src/removeOptionalEmptyObjects.ts
+function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
+  if (!isObject(schema)) {
+    return formData;
+  }
+  const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
+  if (Array.isArray(formData)) {
+    const itemsSchema = resolvedSchema.items;
+    if (!itemsSchema) {
+      return formData;
+    }
+    let hasChanges = false;
+    const mapped = formData.map((item, index) => {
+      let itemSchema = itemsSchema;
+      if (Array.isArray(itemsSchema)) {
+        itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
+      }
+      const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
+      if (cleaned !== item) {
+        hasChanges = true;
+      }
+      return cleaned === void 0 ? {} : cleaned;
+    });
+    return hasChanges ? mapped : formData;
+  }
+  const { properties, required: requiredFields = [] } = resolvedSchema;
+  if (!isObject(formData) || !properties) {
+    return formData;
+  }
+  const result = {};
+  const data = formData;
+  let hasAnyValue = false;
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const propertySchema = properties[key] || {};
+    const isRequired = requiredFields.includes(key);
+    const isObj = isObject(value);
+    const isArr = Array.isArray(value);
+    if ((isObj || isArr) && properties[key]) {
+      const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
+      if (!isRequired && isValueEmpty(cleaned)) {
+        continue;
+      }
+      result[key] = cleaned;
+      hasAnyValue = true;
+    } else if (isRequired || !isValueEmpty(value) || !properties[key]) {
+      result[key] = value;
+      if (!isValueEmpty(value)) {
+        hasAnyValue = true;
+      }
+    }
+  }
+  if (!hasAnyValue && Object.keys(result).length === 0) {
+    return void 0;
+  }
+  return result;
+}
+
 // src/resolveUiSchema.ts
 var import_isEmpty7 = __toESM(require("lodash/isEmpty"), 1);
 function resolveUiSchema(schema, localUiSchema, registry) {
@@ -3612,6 +3793,31 @@ function schemaRequiresTrueValue(schema) {
   return false;
 }
 
+// src/shallowEquals.ts
+function shallowEquals(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // src/shouldRender.ts
 function shouldRender(component, nextProps, nextState, updateStrategy = "customDeep") {
   if (updateStrategy === "always") {
@@ -3626,11 +3832,11 @@ function shouldRender(component, nextProps, nextState, updateStrategy = "customD
 }
 
 // src/shouldRenderOptionalField.ts
-var import_isObject14 = __toESM(require("lodash/isObject"), 1);
+var import_isObject15 = __toESM(require("lodash/isObject"), 1);
 var import_uniq2 = __toESM(require("lodash/uniq"), 1);
 function getSchemaTypesForXxxOf(schemas) {
   const allTypes = (0, import_uniq2.default)(
-    schemas.map((s) => (0, import_isObject14.default)(s) ? getSchemaType(s) : void 0).flat().filter((t) => t !== void 0)
+    schemas.map((s) => (0, import_isObject15.default)(s) ? getSchemaType(s) : void 0).flat().filter((t) => t !== void 0)
   );
   return allTypes.length === 1 ? allTypes[0] : allTypes;
 }
@@ -3912,15 +4118,14 @@ function useFileWidgetProps(value, onChange, multiple = false) {
     [value]
   );
   const handleChange = (0, import_react4.useCallback)(
-    (files) => {
-      processFiles(files).then((filesInfoEvent) => {
-        const newValue = filesInfoEvent.map((fileInfo) => fileInfo.dataURL || null);
-        if (multiple) {
-          onChange(values.concat(...newValue));
-        } else {
-          onChange(newValue[0]);
-        }
-      });
+    async (files) => {
+      const filesInfoEvent = await processFiles(files);
+      const newValue = filesInfoEvent.map((fileInfo) => fileInfo.dataURL || null);
+      if (multiple) {
+        onChange(values.concat(...newValue));
+      } else {
+        onChange(newValue[0]);
+      }
     },
     [values, multiple, onChange]
   );
@@ -3975,7 +4180,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
 }
 
 // src/withIdRefPrefix.ts
-var import_isObject15 = __toESM(require("lodash/isObject"), 1);
+var import_isObject16 = __toESM(require("lodash/isObject"), 1);
 function withIdRefPrefixObject(node) {
   for (const key in node) {
     const realObj = node;
@@ -3998,32 +4203,12 @@ function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if ((0, import_isObject15.default)(schemaNode)) {
+  if ((0, import_isObject16.default)(schemaNode)) {
     return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
 }
 
-// src/nameGenerators.ts
-var bracketNameGenerator = (path, idPrefix, isMultiValue) => {
-  if (!path || path.length === 0) {
-    return idPrefix;
-  }
-  const baseName = path.reduce((acc, pathUnit, index) => {
-    if (index === 0) {
-      return `${idPrefix}[${String(pathUnit)}]`;
-    }
-    return `${acc}[${String(pathUnit)}]`;
-  }, "");
-  return isMultiValue ? `${baseName}[]` : baseName;
-};
-var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
-  if (!path || path.length === 0) {
-    return idPrefix;
-  }
-  return `${idPrefix}.${path.map(String).join(".")}`;
-};
-
 // src/enums.ts
 var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["ArrayItemTitle"] = "Item";