@rjsf/utils 5.23.1 → 5.24.0

package/dist/utils.esm.js

@@ -1,12 +1,15 @@
 // src/isObject.ts
 function isObject(thing) {
-  if (typeof File !== "undefined" && thing instanceof File) {
+  if (typeof thing !== "object" || thing === null) {
     return false;
   }
-  if (typeof Date !== "undefined" && thing instanceof Date) {
+  if (typeof thing.lastModified === "number" && typeof File !== "undefined" && thing instanceof File) {
     return false;
   }
-  return typeof thing === "object" && thing !== null && !Array.isArray(thing);
+  if (typeof thing.getMonth === "function" && typeof Date !== "undefined" && thing instanceof Date) {
+    return false;
+  }
+  return !Array.isArray(thing);
 }
 
 // src/allowAdditionalItems.ts
@@ -279,7 +282,6 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 
 // src/schema/retrieveSchema.ts
 import get4 from "lodash/get";
-import isEqual from "lodash/isEqual";
 import set from "lodash/set";
 import times from "lodash/times";
 import transform from "lodash/transform";
@@ -501,7 +503,10 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       )
     );
     const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
-    return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
+    return allPermutations.map((permutation) => ({
+      ...schema,
+      allOf: permutation
+    }));
   }
   return [schema];
 }
@@ -554,7 +559,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
+  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
   const schema = {
@@ -957,38 +962,48 @@ function isFixedItems(schema) {
 
 // src/mergeDefaultsWithFormData.ts
 import get6 from "lodash/get";
-function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false) {
+import isNil from "lodash/isNil";
+function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
-    const mapped = formData.map((value, idx) => {
-      if (defaultsArray[idx]) {
+    const overrideArray = overrideFormDataWithDefaults ? defaultsArray : formData;
+    const overrideOppositeArray = overrideFormDataWithDefaults ? formData : defaultsArray;
+    const mapped = overrideArray.map((value, idx) => {
+      if (overrideOppositeArray[idx]) {
         return mergeDefaultsWithFormData(
           defaultsArray[idx],
-          value,
+          formData[idx],
           mergeExtraArrayDefaults,
-          defaultSupercedesUndefined
+          defaultSupercedesUndefined,
+          overrideFormDataWithDefaults
         );
       }
       return value;
     });
-    if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) {
-      mapped.push(...defaultsArray.slice(mapped.length));
+    if ((mergeExtraArrayDefaults || overrideFormDataWithDefaults) && mapped.length < overrideOppositeArray.length) {
+      mapped.push(...overrideOppositeArray.slice(mapped.length));
     }
     return mapped;
   }
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
     return Object.keys(formData).reduce((acc2, key) => {
+      const keyValue = get6(formData, key);
+      const keyExistsInDefaults = isObject(defaults) && key in defaults;
+      const keyExistsInFormData = key in formData;
       acc2[key] = mergeDefaultsWithFormData(
         defaults ? get6(defaults, key) : {},
-        get6(formData, key),
+        keyValue,
         mergeExtraArrayDefaults,
-        defaultSupercedesUndefined
+        defaultSupercedesUndefined,
+        // overrideFormDataWithDefaults can be true only when the key value exists in defaults
+        // Or if the key value doesn't exist in formData
+        overrideFormDataWithDefaults && (keyExistsInDefaults || !keyExistsInFormData)
       );
       return acc2;
     }, acc);
   }
-  if (defaultSupercedesUndefined && formData === void 0) {
+  if (defaultSupercedesUndefined && (!isNil(defaults) && isNil(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
     return defaults;
   }
   return formData;
@@ -1044,6 +1059,69 @@ function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAl
   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/toConstant.ts
+function toConstant(schema) {
+  if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
+    return schema.enum[0];
+  }
+  if (CONST_KEY in schema) {
+    return schema.const;
+  }
+  throw new Error("schema cannot be inferred as a constant");
+}
+
+// src/optionsList.ts
+function optionsList(schema, uiSchema) {
+  const schemaWithEnumNames = schema;
+  if (schema.enum) {
+    let enumNames;
+    if (uiSchema) {
+      const { enumNames: uiEnumNames } = getUiOptions(uiSchema);
+      enumNames = uiEnumNames;
+    }
+    if (!enumNames && schemaWithEnumNames.enumNames) {
+      if (true) {
+        console.warn(
+          'The "enumNames" property in the schema is deprecated and will be removed in a future major release. Use the "ui:enumNames" property in the uiSchema instead.'
+        );
+      }
+      enumNames = schemaWithEnumNames.enumNames;
+    }
+    return schema.enum.map((value, i) => {
+      const label = enumNames?.[i] || String(value);
+      return { label, value };
+    });
+  }
+  let altSchemas = void 0;
+  let altUiSchemas = void 0;
+  if (schema.anyOf) {
+    altSchemas = schema.anyOf;
+    altUiSchemas = uiSchema?.anyOf;
+  } else if (schema.oneOf) {
+    altSchemas = schema.oneOf;
+    altUiSchemas = uiSchema?.oneOf;
+  }
+  return altSchemas && altSchemas.map((aSchemaDef, index) => {
+    const { title } = getUiOptions(altUiSchemas?.[index]);
+    const aSchema = aSchemaDef;
+    const value = toConstant(aSchema);
+    const label = title || aSchema.title || String(value);
+    return {
+      schema: aSchema,
+      label,
+      value
+    };
+  });
+}
+
 // src/schema/getDefaultFormState.ts
 var PRIMITIVE_TYPES = ["string", "number", "integer", "boolean", "null"];
 function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, idx = -1) {
@@ -1067,8 +1145,8 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
   if (includeUndefinedValues || isConst) {
     obj[key] = computedDefault;
   } else if (emptyObjectFields !== "skipDefaults") {
+    const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
     if (isObject(computedDefault)) {
-      const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
       if (emptyObjectFields === "skipEmptyDefaults") {
         if (!isEmpty(computedDefault)) {
           obj[key] = computedDefault;
@@ -1079,8 +1157,9 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
     } else if (
       // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
       // Condition 1: computedDefault is not undefined
-      // Condition 2: If emptyObjectFields is 'populateAllDefaults' or 'skipEmptyDefaults) or if the key is a required field
-      computedDefault !== void 0 && (emptyObjectFields === "populateAllDefaults" || emptyObjectFields === "skipEmptyDefaults" || requiredFields.includes(key))
+      // Condition 2: If emptyObjectFields is 'populateAllDefaults' or 'skipEmptyDefaults)
+      // Or if isSelfOrParentRequired is 'true' and the key is a required field
+      computedDefault !== void 0 && (emptyObjectFields === "populateAllDefaults" || emptyObjectFields === "skipEmptyDefaults" || isSelfOrParentRequired && requiredFields.includes(key))
     ) {
       obj[key] = computedDefault;
     }
@@ -1095,7 +1174,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     _recurseList = [],
     experimental_defaultFormStateBehavior = void 0,
     experimental_customMergeAllOf = void 0,
-    required
+    required,
+    shouldMergeDefaultsIntoFormData = false
   } = computeDefaultsProps;
   const formData = isObject(rawFormData) ? rawFormData : {};
   const schema = isObject(rawSchema) ? rawSchema : {};
@@ -1103,8 +1183,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   let schemaToCompute = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
-  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never") {
-    defaults = schema.const;
+  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
+    defaults = schema[CONST_KEY];
   } else if (isObject(defaults) && isObject(schema.default)) {
     defaults = mergeObjects(defaults, schema.default);
   } else if (DEFAULT_KEY in schema) {
@@ -1140,7 +1220,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
         experimental_customMergeAllOf,
         parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : void 0,
         rawFormData: formData,
-        required
+        required,
+        shouldMergeDefaultsIntoFormData
       })
     );
   } else if (ONE_OF_KEY in schema) {
@@ -1151,12 +1232,15 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     const discriminator = getDiscriminatorFieldFromSchema(schema);
     const { type = "null" } = remaining;
     if (!Array.isArray(type) && PRIMITIVE_TYPES.includes(type) && experimental_dfsb_to_compute?.constAsDefaults === "skipOneOf") {
-      experimental_dfsb_to_compute = { ...experimental_dfsb_to_compute, constAsDefaults: "never" };
+      experimental_dfsb_to_compute = {
+        ...experimental_dfsb_to_compute,
+        constAsDefaults: "never"
+      };
     }
     schemaToCompute = oneOf[getClosestMatchingOption(
       validator,
       rootSchema,
-      isEmpty(formData) ? void 0 : formData,
+      rawFormData,
       oneOf,
       0,
       discriminator,
@@ -1172,7 +1256,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     schemaToCompute = anyOf[getClosestMatchingOption(
       validator,
       rootSchema,
-      isEmpty(formData) ? void 0 : formData,
+      rawFormData,
       anyOf,
       0,
       discriminator,
@@ -1189,14 +1273,49 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       experimental_customMergeAllOf,
       parentDefaults: defaults,
       rawFormData: formData,
-      required
+      required,
+      shouldMergeDefaultsIntoFormData
     });
   }
   if (defaults === void 0) {
     defaults = schema.default;
   }
   const defaultBasedOnSchemaType = getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults);
-  return defaultBasedOnSchemaType ?? defaults;
+  let defaultsWithFormData = defaultBasedOnSchemaType ?? defaults;
+  if (shouldMergeDefaultsIntoFormData) {
+    const { arrayMinItems = {} } = experimental_defaultFormStateBehavior || {};
+    const { mergeExtraDefaults } = arrayMinItems;
+    const matchingFormData = ensureFormDataMatchingSchema(
+      validator,
+      schema,
+      rootSchema,
+      rawFormData,
+      experimental_defaultFormStateBehavior
+    );
+    if (!isObject(rawFormData)) {
+      defaultsWithFormData = mergeDefaultsWithFormData(
+        defaultsWithFormData,
+        matchingFormData,
+        mergeExtraDefaults,
+        true
+      );
+    }
+  }
+  return defaultsWithFormData;
+}
+function ensureFormDataMatchingSchema(validator, schema, rootSchema, formData, experimental_defaultFormStateBehavior) {
+  const isSelectField = !isConstant(schema) && isSelect(validator, schema, rootSchema);
+  let validFormData = formData;
+  if (isSelectField) {
+    const getOptionsList = optionsList(schema);
+    const isValid = getOptionsList?.some((option) => deepEquals(option.value, formData));
+    validFormData = isValid ? formData : void 0;
+  }
+  const constTakesPrecedence = schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === "always";
+  if (constTakesPrecedence) {
+    validFormData = schema.const;
+  }
+  return validFormData;
 }
 function getObjectDefaults(validator, rawSchema, {
   rawFormData,
@@ -1205,7 +1324,8 @@ function getObjectDefaults(validator, rawSchema, {
   _recurseList = [],
   experimental_defaultFormStateBehavior = void 0,
   experimental_customMergeAllOf = void 0,
-  required
+  required,
+  shouldMergeDefaultsIntoFormData
 } = {}, defaults) {
   {
     const formData = isObject(rawFormData) ? rawFormData : {};
@@ -1216,7 +1336,7 @@ function getObjectDefaults(validator, rawSchema, {
       (acc, key) => {
         const propertySchema = get7(retrievedSchema, [PROPERTIES_KEY, key]);
         const hasParentConst = isObject(parentConst) && parentConst[key] !== void 0;
-        const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema || hasParentConst) && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
+        const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema || hasParentConst) && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(propertySchema);
         const computedDefault = computeDefaults(validator, propertySchema, {
           rootSchema,
           _recurseList,
@@ -1225,7 +1345,8 @@ function getObjectDefaults(validator, rawSchema, {
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: get7(defaults, [key]),
           rawFormData: get7(formData, [key]),
-          required: retrievedSchema.required?.includes(key)
+          required: retrievedSchema.required?.includes(key),
+          shouldMergeDefaultsIntoFormData
         });
         maybeAddDefaultToObject(
           acc,
@@ -1243,16 +1364,16 @@ function getObjectDefaults(validator, rawSchema, {
     );
     if (retrievedSchema.additionalProperties) {
       const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
-      const keys = /* @__PURE__ */ new Set();
+      const keys2 = /* @__PURE__ */ new Set();
       if (isObject(defaults)) {
-        Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys.add(key));
+        Object.keys(defaults).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => keys2.add(key));
       }
       const formDataRequired = [];
       Object.keys(formData).filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]).forEach((key) => {
-        keys.add(key);
+        keys2.add(key);
         formDataRequired.push(key);
       });
-      keys.forEach((key) => {
+      keys2.forEach((key) => {
         const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
           rootSchema,
           _recurseList,
@@ -1261,7 +1382,8 @@ function getObjectDefaults(validator, rawSchema, {
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: get7(defaults, [key]),
           rawFormData: get7(formData, [key]),
-          required: retrievedSchema.required?.includes(key)
+          required: retrievedSchema.required?.includes(key),
+          shouldMergeDefaultsIntoFormData
         });
         maybeAddDefaultToObject(
           objectDefaults,
@@ -1282,7 +1404,8 @@ function getArrayDefaults(validator, rawSchema, {
   _recurseList = [],
   experimental_defaultFormStateBehavior = void 0,
   experimental_customMergeAllOf = void 0,
-  required
+  required,
+  shouldMergeDefaultsIntoFormData
 } = {}, defaults) {
   const schema = rawSchema;
   const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
@@ -1302,7 +1425,8 @@ function getArrayDefaults(validator, rawSchema, {
         experimental_defaultFormStateBehavior,
         experimental_customMergeAllOf,
         parentDefaults: item,
-        required
+        required,
+        shouldMergeDefaultsIntoFormData
       });
     });
   }
@@ -1319,7 +1443,8 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_customMergeAllOf,
           rawFormData: item,
           parentDefaults: get7(defaults, [idx]),
-          required
+          required,
+          shouldMergeDefaultsIntoFormData
         });
       });
       const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
@@ -1349,7 +1474,8 @@ function getArrayDefaults(validator, rawSchema, {
       _recurseList,
       experimental_defaultFormStateBehavior,
       experimental_customMergeAllOf,
-      required
+      required,
+      shouldMergeDefaultsIntoFormData
     })
   );
   return defaultEntries.concat(fillerEntries);
@@ -1374,21 +1500,24 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
     includeUndefinedValues,
     experimental_defaultFormStateBehavior,
     experimental_customMergeAllOf,
-    rawFormData: formData
+    rawFormData: formData,
+    shouldMergeDefaultsIntoFormData: true
   });
-  if (formData === void 0 || formData === null || typeof formData === "number" && isNaN(formData)) {
-    return defaults;
-  }
-  const { mergeDefaultsIntoFormData, arrayMinItems = {} } = experimental_defaultFormStateBehavior || {};
-  const { mergeExtraDefaults } = arrayMinItems;
-  const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
-  if (isObject(formData)) {
-    return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults, defaultSupercedesUndefined);
-  }
-  if (Array.isArray(formData)) {
-    return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults, defaultSupercedesUndefined);
+  if (isObject(formData) || Array.isArray(formData)) {
+    const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
+    const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
+    const result = mergeDefaultsWithFormData(
+      defaults,
+      formData,
+      true,
+      // set to true to add any additional default array entries.
+      defaultSupercedesUndefined,
+      true
+      // set to true to override formData with defaults if they exist.
+    );
+    return result;
   }
-  return formData;
+  return defaults;
 }
 
 // src/isCustomWidget.ts
@@ -1471,9 +1600,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         }
       });
     }
-    const keys = Object.keys(get8(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys(get8(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
-    keys.forEach((key) => {
+    keys2.forEach((key) => {
       const formValue = get8(data, key);
       let oldKeyedSchema = get8(oldSchema, [PROPERTIES_KEY, key], {});
       let newKeyedSchema = get8(newSchema, [PROPERTIES_KEY, key], {});
@@ -1590,11 +1719,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 
 // src/schema/toIdSchema.ts
 import get9 from "lodash/get";
-import isEqual2 from "lodash/isEqual";
 function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual2(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1661,12 +1789,11 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 
 // src/schema/toPathSchema.ts
 import get10 from "lodash/get";
-import isEqual3 from "lodash/isEqual";
 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) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual3(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -2104,9 +2231,6 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
-// src/enumOptionsDeselectValue.ts
-import isEqual4 from "lodash/isEqual";
-
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -2121,18 +2245,17 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !isEqual4(v, value));
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return isEqual4(value, selected) ? void 0 : selected;
+  return deepEquals(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
-import isEqual5 from "lodash/isEqual";
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => isEqual5(sel, value));
+    return selected.some((sel) => deepEquals(sel, value));
   }
-  return isEqual5(selected, value);
+  return deepEquals(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -2145,10 +2268,10 @@ function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false)
 }
 
 // src/enumOptionsSelectValue.ts
-import isNil from "lodash/isNil";
+import isNil2 from "lodash/isNil";
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!isNil(value)) {
+  if (!isNil2(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));
@@ -2478,9 +2601,9 @@ function hasWidget(schema, widget, registeredWidgets = {}) {
 }
 
 // src/idGenerators.ts
-import isString3 from "lodash/isString";
+import isString4 from "lodash/isString";
 function idGenerator(id, suffix) {
-  const theId = isString3(id) ? id : id[ID_KEY];
+  const theId = isString4(id) ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 function descriptionId(id) {
@@ -2516,61 +2639,6 @@ function localToUTC(dateString) {
   return dateString ? new Date(dateString).toJSON() : void 0;
 }
 
-// src/toConstant.ts
-function toConstant(schema) {
-  if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
-    return schema.enum[0];
-  }
-  if (CONST_KEY in schema) {
-    return schema.const;
-  }
-  throw new Error("schema cannot be inferred as a constant");
-}
-
-// src/optionsList.ts
-function optionsList(schema, uiSchema) {
-  const schemaWithEnumNames = schema;
-  if (schema.enum) {
-    let enumNames;
-    if (uiSchema) {
-      const { enumNames: uiEnumNames } = getUiOptions(uiSchema);
-      enumNames = uiEnumNames;
-    }
-    if (!enumNames && schemaWithEnumNames.enumNames) {
-      if (true) {
-        console.warn(
-          'The "enumNames" property in the schema is deprecated and will be removed in a future major release. Use the "ui:enumNames" property in the uiSchema instead.'
-        );
-      }
-      enumNames = schemaWithEnumNames.enumNames;
-    }
-    return schema.enum.map((value, i) => {
-      const label = enumNames?.[i] || String(value);
-      return { label, value };
-    });
-  }
-  let altSchemas = void 0;
-  let altUiSchemas = void 0;
-  if (schema.anyOf) {
-    altSchemas = schema.anyOf;
-    altUiSchemas = uiSchema?.anyOf;
-  } else if (schema.oneOf) {
-    altSchemas = schema.oneOf;
-    altUiSchemas = uiSchema?.oneOf;
-  }
-  return altSchemas && altSchemas.map((aSchemaDef, index) => {
-    const { title } = getUiOptions(altUiSchemas?.[index]);
-    const aSchema = aSchemaDef;
-    const value = toConstant(aSchema);
-    const label = title || aSchema.title || String(value);
-    return {
-      schema: aSchema,
-      label,
-      value
-    };
-  });
-}
-
 // src/orderProperties.ts
 function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
@@ -2792,6 +2860,29 @@ function withIdRefPrefix(schemaNode) {
   return schemaNode;
 }
 
+// src/getChangedFields.ts
+import keys from "lodash/keys";
+import pickBy from "lodash/pickBy";
+import isPlainObject4 from "lodash/isPlainObject";
+import get13 from "lodash/get";
+import difference from "lodash/difference";
+function getChangedFields(a, b) {
+  const aIsPlainObject = isPlainObject4(a);
+  const bIsPlainObject = isPlainObject4(b);
+  if (a === b || !aIsPlainObject && !bIsPlainObject) {
+    return [];
+  }
+  if (aIsPlainObject && !bIsPlainObject) {
+    return keys(a);
+  } else if (!aIsPlainObject && bIsPlainObject) {
+    return keys(b);
+  } else {
+    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get13(b, key))));
+    const diffFields = difference(keys(b), keys(a));
+    return [...unequalFields, ...diffFields];
+  }
+}
+
 // src/enums.ts
 var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["ArrayItemTitle"] = "Item";
@@ -2828,11 +2919,9 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 import forEach from "lodash/forEach";
-import isEqual7 from "lodash/isEqual";
 
 // src/parser/ParserValidator.ts
-import get13 from "lodash/get";
-import isEqual6 from "lodash/isEqual";
+import get14 from "lodash/get";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2858,12 +2947,12 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get13(schema, ID_KEY, hash);
+    const key = get14(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!isEqual6(existing, identifiedSchema)) {
+    } else if (!deepEquals(existing, identifiedSchema)) {
       console.error("existing schema:", JSON.stringify(existing, null, 2));
       console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
       throw new Error(
@@ -2885,7 +2974,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!isEqual6(rootSchema, this.rootSchema)) {
+    if (!deepEquals(rootSchema, this.rootSchema)) {
       throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
@@ -2925,7 +3014,7 @@ var ParserValidator = class {
 function parseSchema(validator, recurseList, rootSchema, schema) {
   const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
   schemas.forEach((schema2) => {
-    const sameSchemaIndex = recurseList.findIndex((item) => isEqual7(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);
@@ -2997,6 +3086,7 @@ export {
   errorId,
   examplesId,
   findSchemaDefinition,
+  getChangedFields,
   getClosestMatchingOption,
   getDateElementProps,
   getDefaultFormState,