@rjsf/utils 6.5.2 → 6.6.0

package/dist/utils.esm.js

@@ -144,6 +144,9 @@ function createErrorHandler(formData) {
   return handler;
 }
 
+// src/createSchemaUtils.ts
+import get17 from "lodash/get";
+
 // src/deepEquals.ts
 import { createCustomEqual } from "fast-equals";
 var deepEquals = createCustomEqual({
@@ -156,32 +159,13 @@ var deepEquals = createCustomEqual({
 });
 var deepEquals_default = deepEquals;
 
-// src/schema/findFieldInSchema.ts
-import get8 from "lodash/get";
-import has3 from "lodash/has";
-
-// src/schema/findSelectedOptionInXxxOf.ts
-import get6 from "lodash/get";
-
-// src/schema/retrieveSchema.ts
-import get5 from "lodash/get";
-import set from "lodash/set";
-import times from "lodash/times";
-import transform from "lodash/transform";
-import merge from "lodash/merge";
-import flattenDeep from "lodash/flattenDeep";
-import uniq from "lodash/uniq";
-import isEmpty2 from "lodash/isEmpty";
-import { createComparator, createMerger, createShallowAllOfMerge } from "@x0k/json-schema-merge";
-import { createDeduplicator, createIntersector } from "@x0k/json-schema-merge/lib/array";
-
 // src/findSchemaDefinition.ts
-import jsonpointer from "jsonpointer";
-import omit from "lodash/omit";
-import isObject2 from "lodash/isObject";
-import isEmpty from "lodash/isEmpty";
 import UriResolver from "fast-uri";
+import jsonpointer from "jsonpointer";
 import get from "lodash/get";
+import isEmpty from "lodash/isEmpty";
+import isObject2 from "lodash/isObject";
+import omit from "lodash/omit";
 function findEmbeddedSchemaRecursive(schema, ref) {
   if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY], ref)) {
     return schema;
@@ -282,6 +266,13 @@ function findSchemaDefinition($ref, rootSchema = {}, baseURI = get(rootSchema, [
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }
 
+// src/schema/findFieldInSchema.ts
+import get8 from "lodash/get";
+import has3 from "lodash/has";
+
+// src/schema/findSelectedOptionInXxxOf.ts
+import get6 from "lodash/get";
+
 // src/getDiscriminatorFieldFromSchema.ts
 import get2 from "lodash/get";
 import isString from "lodash/isString";
@@ -296,6 +287,16 @@ function getDiscriminatorFieldFromSchema(schema) {
   return discriminator;
 }
 
+// src/schema/retrieveSchema.ts
+import flattenDeep from "lodash/flattenDeep";
+import get5 from "lodash/get";
+import isEmpty2 from "lodash/isEmpty";
+import merge from "lodash/merge";
+import set from "lodash/set";
+import times from "lodash/times";
+import transform from "lodash/transform";
+import uniq from "lodash/uniq";
+
 // src/guessType.ts
 function guessType(value) {
   if (Array.isArray(value)) {
@@ -437,6 +438,16 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
   return 0;
 }
 
+// src/schema/shallowAllOfMerge.ts
+import { createComparator, createMerger, createShallowAllOfMerge } from "@x0k/json-schema-merge";
+import { createDeduplicator, createIntersector } from "@x0k/json-schema-merge/lib/array";
+var { compareSchemaDefinitions, compareSchemaValues } = createComparator();
+var { mergeArrayOfSchemaDefinitions } = createMerger({
+  intersectJson: createIntersector(compareSchemaValues),
+  deduplicateJsonSchemaDef: createDeduplicator(compareSchemaDefinitions)
+});
+var shallowAllOfMerge_default = createShallowAllOfMerge(mergeArrayOfSchemaDefinitions);
+
 // src/schema/retrieveSchema.ts
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs = false) {
   return retrieveSchemaInternal(
@@ -723,14 +734,8 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
   });
   return schema;
 }
-var { compareSchemaDefinitions, compareSchemaValues } = createComparator();
-var { mergeArrayOfSchemaDefinitions } = createMerger({
-  intersectJson: createIntersector(compareSchemaValues),
-  deduplicateJsonSchemaDef: createDeduplicator(compareSchemaDefinitions)
-});
-var shallowAllOfMerge = 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)) {
@@ -837,12 +842,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(
@@ -1024,9 +1040,9 @@ function getFromSchemaInternal(validator, rootSchema, schema, path, experimental
   if (isEmpty3(path)) {
     return fieldSchema;
   }
-  const pathList = Array.isArray(path) ? path : path.split(".");
+  const pathList = Array.isArray(path) ? [...path] : path.split(".");
   const [part, ...nestedPath] = pathList;
-  if (part && has2(fieldSchema, part)) {
+  if (part !== void 0 && part !== "" && has2(fieldSchema, part)) {
     fieldSchema = get7(fieldSchema, part);
     return getFromSchemaInternal(
       validator,
@@ -1052,6 +1068,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
   const pathList = Array.isArray(path) ? [...path] : path.split(".");
   let parentField = schema;
   const fieldName = pathList.pop();
+  const fieldNameKey = String(fieldName);
   if (pathList.length) {
     pathList.forEach((subPath) => {
       parentField = getFromSchema(
@@ -1067,7 +1084,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
           validator,
           rootSchema,
           parentField,
-          fieldName,
+          fieldNameKey,
           ONE_OF_KEY,
           get8(formData, subPath),
           experimental_customMergeAllOf
@@ -1077,7 +1094,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
           validator,
           rootSchema,
           parentField,
-          fieldName,
+          fieldNameKey,
           ANY_OF_KEY,
           get8(formData, subPath),
           experimental_customMergeAllOf
@@ -1090,7 +1107,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
       validator,
       rootSchema,
       parentField,
-      fieldName,
+      fieldNameKey,
       ONE_OF_KEY,
       formData,
       experimental_customMergeAllOf
@@ -1100,7 +1117,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
       validator,
       rootSchema,
       parentField,
-      fieldName,
+      fieldNameKey,
       ANY_OF_KEY,
       formData,
       experimental_customMergeAllOf
@@ -1127,15 +1144,11 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
   );
   let isRequired;
   if (field && Array.isArray(requiredArray)) {
-    isRequired = requiredArray.includes(fieldName);
+    isRequired = requiredArray.includes(fieldNameKey);
   }
   return { field, isRequired };
 }
 
-// src/schema/getDefaultFormState.ts
-import get12 from "lodash/get";
-import isEmpty4 from "lodash/isEmpty";
-
 // src/schema/getClosestMatchingOption.ts
 import get9 from "lodash/get";
 import has4 from "lodash/has";
@@ -1260,6 +1273,23 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
   return bestIndex;
 }
 
+// src/schema/getDefaultFormState.ts
+import get12 from "lodash/get";
+import isEmpty4 from "lodash/isEmpty";
+
+// src/constIsAjvDataReference.ts
+import isString3 from "lodash/isString";
+function constIsAjvDataReference(schema) {
+  const schemaConst = schema[CONST_KEY];
+  const schemaType = getSchemaType(schema);
+  return isObject(schemaConst) && isString3(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));
@@ -1297,7 +1327,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
       const keyDefault = get10(defaults, key) ?? {};
-      const defaultValueIsNestedObject = keyExistsInDefaults && Object.entries(keyDefault).some(([, v]) => isObject(v));
+      const defaultValueIsNestedObject = keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
       const keyDefaultIsObject = keyExistsInDefaults && isObject(get10(defaults, key));
       const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
       if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
@@ -1352,40 +1382,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
-import isString3 from "lodash/isString";
-function constIsAjvDataReference(schema) {
-  const schemaConst = schema[CONST_KEY];
-  const schemaType = getSchemaType(schema);
-  return isObject(schemaConst) && isString3(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
-}
-
 // src/optionsList.ts
 import get11 from "lodash/get";
 
@@ -1466,6 +1462,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) {
@@ -1825,14 +1842,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;
@@ -1962,210 +1976,269 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
 }
 
 // src/schema/omitExtraData.ts
-import pick from "lodash/pick";
-import isEmpty5 from "lodash/isEmpty";
-import get15 from "lodash/get";
-
-// src/schema/toPathSchema.ts
 import get14 from "lodash/get";
-import isObject4 from "lodash/isObject";
-import set2 from "lodash/set";
-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
-      );
-    }
+import isEmpty5 from "lodash/isEmpty";
+import isNil2 from "lodash/isNil";
+import pick from "lodash/pick";
+function getUsedFormData(formData, fields) {
+  if (fields.length === 0 && typeof formData !== "object") {
+    return formData;
   }
-  let pathSchema = {
-    [NAME_KEY]: name.replace(/^\./, "")
+  const data = pick(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" || isEmpty5(value) || isLeaf && !isEmpty5(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 = get14(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 (isNil2(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) {
-    set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-    const additionalSchema = isObject4(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
-    const definedProperties = get14(schema, PROPERTIES_KEY, {});
-    for (const key of Object.keys(formData ?? {})) {
-      if (!(key in definedProperties)) {
-        pathSchema[key] = toPathSchemaInternal(
-          validator,
-          additionalSchema,
-          `${name}.${key}`,
-          rootSchema,
-          get14(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 = get14(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
-        get14(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 = pick(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" || isEmpty5(value) || isLeaf && !isEmpty5(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 = get15(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 || isEmpty5(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
-import get16 from "lodash/get";
+import get15 from "lodash/get";
 import has5 from "lodash/has";
-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 (has5(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if (has5(oldSchema, PROPERTIES_KEY)) {
-      const properties = get16(oldSchema, PROPERTIES_KEY, {});
+      const properties = get15(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if (has5(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys(get16(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys(get15(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = get16(data, key);
-      let oldKeyedSchema = get16(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get16(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = get15(data, key);
+      let oldKeyedSchema = get15(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get15(newSchema, [PROPERTIES_KEY, key], {});
       if (has5(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -2184,8 +2257,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = get16(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = get16(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = get15(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get15(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if (has5(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -2203,17 +2276,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = get16(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = get16(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = get15(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get15(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get16(newKeyedSchema, "readOnly") === true) {
+            } else if (get15(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get16(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = get16(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = get15(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get15(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -2225,9 +2298,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if (get16(oldSchema, "type") === "array" && get16(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = get16(oldSchema, "items");
-    let newSchemaItems = get16(newSchema, "items");
+  } else if (get15(oldSchema, "type") === "array" && get15(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get15(oldSchema, "items");
+    let newSchemaItems = get15(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if (has5(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -2247,10 +2320,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = get16(oldSchemaItems, "type");
-      const newSchemaType = get16(newSchemaItems, "type");
+      const oldSchemaType = get15(oldSchemaItems, "type");
+      const newSchemaType = get15(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get16(newSchema, "maxItems", -1);
+        const maxItems = get15(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2277,8 +2350,137 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
+// src/schema/toPathSchema.ts
+import get16 from "lodash/get";
+import isObject4 from "lodash/isObject";
+import set2 from "lodash/set";
+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) {
+    set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+    const additionalSchema = isObject4(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {};
+    const definedProperties = get16(schema, PROPERTIES_KEY, {});
+    for (const key of Object.keys(formData ?? {})) {
+      if (!(key in definedProperties)) {
+        pathSchema[key] = toPathSchemaInternal(
+          validator,
+          additionalSchema,
+          `${name}.${key}`,
+          rootSchema,
+          get16(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 = get16(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
+        get16(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
-import get17 from "lodash/get";
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2618,31 +2820,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;
@@ -2656,12 +2833,31 @@ function replaceStringParameters(inputString, params) {
     });
     output = parts.join("");
   }
-  return output;
+  return output;
+}
+
+// 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/englishStringTranslator.ts
-function englishStringTranslator(stringToTranslate, params) {
-  return replaceStringParameters(stringToTranslate, params);
+// 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
@@ -2694,14 +2890,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
+import isNil3 from "lodash/isNil";
+function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
+  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  if (!isNil3(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
@@ -2730,12 +2929,12 @@ function enumOptionValueDecoder(value, enumOptions, format = "indexed", emptyVal
 }
 
 // src/enumOptionValueEncoder.ts
-import isNil2 from "lodash/isNil";
+import isNil4 from "lodash/isNil";
 function enumOptionValueEncoder(value, index, format = "indexed") {
   if (format !== "realValue") {
     return String(index);
   }
-  if (isNil2(value)) {
+  if (isNil4(value)) {
     return "";
   }
   if (typeof value === "object") {
@@ -2744,28 +2943,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
-import isNil3 from "lodash/isNil";
-function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
-  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!isNil3(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
 import cloneDeep from "lodash/cloneDeep";
 import get18 from "lodash/get";
@@ -2864,11 +3041,11 @@ var ErrorSchemaBuilder = class {
 };
 
 // src/getChangedFields.ts
+import difference from "lodash/difference";
+import get19 from "lodash/get";
+import isPlainObject2 from "lodash/isPlainObject";
 import keys from "lodash/keys";
 import pickBy from "lodash/pickBy";
-import isPlainObject2 from "lodash/isPlainObject";
-import get19 from "lodash/get";
-import difference from "lodash/difference";
 function getChangedFields(a, b) {
   const aIsPlainObject = isPlainObject2(a);
   const bIsPlainObject = isPlainObject2(b);
@@ -3010,7 +3187,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 import get20 from "lodash/get";
 import uniqueId from "lodash/uniqueId";
 function getTestIds() {
-  if (typeof process === "undefined" || get20(process, "env.NODE_ENV") !== "test") {
+  if (get20(globalThis, "process.env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3029,9 +3206,9 @@ function getTestIds() {
 
 // src/getWidget.tsx
 import { createElement } from "react";
-import ReactIs from "react-is";
 import get21 from "lodash/get";
 import set4 from "lodash/set";
+import ReactIs from "react-is";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
   boolean: {
@@ -3192,11 +3369,11 @@ function optionalControlsId(id, element) {
 }
 
 // src/isFormDataAvailable.ts
-import isNil4 from "lodash/isNil";
 import isEmpty6 from "lodash/isEmpty";
+import isNil5 from "lodash/isNil";
 import isObject5 from "lodash/isObject";
 function isFormDataAvailable(formData) {
-  return !isNil4(formData) && (!isObject5(formData) || Array.isArray(formData) || !isEmpty6(formData));
+  return !isNil5(formData) && (!isObject5(formData) || Array.isArray(formData) || !isEmpty6(formData));
 }
 
 // src/isRootSchema.ts
@@ -3234,80 +3411,25 @@ function lookupFromFormContext(regOrFc, toLookup, fallback) {
   return get22(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
-// src/removeOptionalEmptyObjects.ts
-import isNil5 from "lodash/isNil";
-function isValueEmpty(value) {
-  if (isNil5(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) {
@@ -3365,6 +3487,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
 import isEmpty7 from "lodash/isEmpty";
 function resolveUiSchema(schema, localUiSchema, registry) {
@@ -3435,6 +3615,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") {
@@ -3735,15 +3940,14 @@ function useFileWidgetProps(value, onChange, multiple = false) {
     [value]
   );
   const handleChange = useCallback2(
-    (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]
   );
@@ -3827,26 +4031,6 @@ function withIdRefPrefix(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";
@@ -3879,6 +4063,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["OptionPrefix"] = "Option %1";
   TranslatableString2["TitleOptionPrefix"] = "%1 option %2";
   TranslatableString2["KeyLabel"] = "%1 Key";
+  TranslatableString2["DeprecatedLabel"] = "%1 (deprecated)";
   TranslatableString2["InvalidObjectField"] = 'Invalid "%1" object field configuration: _%2_.';
   TranslatableString2["UnsupportedField"] = "Unsupported field schema.";
   TranslatableString2["UnsupportedFieldWithId"] = "Unsupported field schema for field `%1`.";
@@ -4111,6 +4296,7 @@ export {
   isObject,
   isRootSchema,
   isSelect,
+  isValueEmpty,
   labelValue,
   localToUTC,
   lookupFromFormContext,
@@ -4125,6 +4311,7 @@ export {
   pad,
   parseDateString,
   rangeSpec,
+  relaxOptionsForScoring,
   removeOptionalEmptyObjects,
   replaceStringParameters,
   resolveUiSchema,