@rjsf/utils 5.23.1 → 5.24.0

package/dist/index.js

@@ -78,6 +78,7 @@ __export(src_exports, {
   errorId: () => errorId,
   examplesId: () => examplesId,
   findSchemaDefinition: () => findSchemaDefinition,
+  getChangedFields: () => getChangedFields,
   getClosestMatchingOption: () => getClosestMatchingOption,
   getDateElementProps: () => getDateElementProps,
   getDefaultFormState: () => getDefaultFormState,
@@ -137,13 +138,16 @@ module.exports = __toCommonJS(src_exports);
 
 // 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
@@ -416,7 +420,6 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 
 // src/schema/retrieveSchema.ts
 var import_get4 = __toESM(require("lodash/get"));
-var import_isEqual = __toESM(require("lodash/isEqual"));
 var import_set = __toESM(require("lodash/set"));
 var import_times = __toESM(require("lodash/times"));
 var import_transform = __toESM(require("lodash/transform"));
@@ -638,7 +641,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];
 }
@@ -691,7 +697,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
       items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList)
     };
   }
-  return (0, import_isEqual.default)(schema, resolvedSchema) ? schema : resolvedSchema;
+  return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
   const schema = {
@@ -1094,38 +1100,48 @@ function isFixedItems(schema) {
 
 // src/mergeDefaultsWithFormData.ts
 var import_get6 = __toESM(require("lodash/get"));
-function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false) {
+var import_isNil = __toESM(require("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 = (0, import_get6.default)(formData, key);
+      const keyExistsInDefaults = isObject(defaults) && key in defaults;
+      const keyExistsInFormData = key in formData;
       acc2[key] = mergeDefaultsWithFormData(
         defaults ? (0, import_get6.default)(defaults, key) : {},
-        (0, import_get6.default)(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 && (!(0, import_isNil.default)(defaults) && (0, import_isNil.default)(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
     return defaults;
   }
   return formData;
@@ -1181,6 +1197,69 @@ function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAl
   return isSelect(validator, schema.items, rootSchema, experimental_customMergeAllOf);
 }
 
+// src/constIsAjvDataReference.ts
+var import_isString3 = __toESM(require("lodash/isString"));
+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/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) {
@@ -1204,8 +1283,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 (!(0, import_isEmpty.default)(computedDefault)) {
           obj[key] = computedDefault;
@@ -1216,8 +1295,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;
     }
@@ -1232,7 +1312,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 : {};
@@ -1240,8 +1321,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) {
@@ -1277,7 +1358,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) {
@@ -1288,12 +1370,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,
-      (0, import_isEmpty.default)(formData) ? void 0 : formData,
+      rawFormData,
       oneOf,
       0,
       discriminator,
@@ -1309,7 +1394,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     schemaToCompute = anyOf[getClosestMatchingOption(
       validator,
       rootSchema,
-      (0, import_isEmpty.default)(formData) ? void 0 : formData,
+      rawFormData,
       anyOf,
       0,
       discriminator,
@@ -1326,14 +1411,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,
@@ -1342,7 +1462,8 @@ function getObjectDefaults(validator, rawSchema, {
   _recurseList = [],
   experimental_defaultFormStateBehavior = void 0,
   experimental_customMergeAllOf = void 0,
-  required
+  required,
+  shouldMergeDefaultsIntoFormData
 } = {}, defaults) {
   {
     const formData = isObject(rawFormData) ? rawFormData : {};
@@ -1353,7 +1474,7 @@ function getObjectDefaults(validator, rawSchema, {
       (acc, key) => {
         const propertySchema = (0, import_get7.default)(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,
@@ -1362,7 +1483,8 @@ function getObjectDefaults(validator, rawSchema, {
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: (0, import_get7.default)(defaults, [key]),
           rawFormData: (0, import_get7.default)(formData, [key]),
-          required: retrievedSchema.required?.includes(key)
+          required: retrievedSchema.required?.includes(key),
+          shouldMergeDefaultsIntoFormData
         });
         maybeAddDefaultToObject(
           acc,
@@ -1380,16 +1502,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,
@@ -1398,7 +1520,8 @@ function getObjectDefaults(validator, rawSchema, {
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: (0, import_get7.default)(defaults, [key]),
           rawFormData: (0, import_get7.default)(formData, [key]),
-          required: retrievedSchema.required?.includes(key)
+          required: retrievedSchema.required?.includes(key),
+          shouldMergeDefaultsIntoFormData
         });
         maybeAddDefaultToObject(
           objectDefaults,
@@ -1419,7 +1542,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 ?? {};
@@ -1439,7 +1563,8 @@ function getArrayDefaults(validator, rawSchema, {
         experimental_defaultFormStateBehavior,
         experimental_customMergeAllOf,
         parentDefaults: item,
-        required
+        required,
+        shouldMergeDefaultsIntoFormData
       });
     });
   }
@@ -1456,7 +1581,8 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_customMergeAllOf,
           rawFormData: item,
           parentDefaults: (0, import_get7.default)(defaults, [idx]),
-          required
+          required,
+          shouldMergeDefaultsIntoFormData
         });
       });
       const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
@@ -1486,7 +1612,8 @@ function getArrayDefaults(validator, rawSchema, {
       _recurseList,
       experimental_defaultFormStateBehavior,
       experimental_customMergeAllOf,
-      required
+      required,
+      shouldMergeDefaultsIntoFormData
     })
   );
   return defaultEntries.concat(fillerEntries);
@@ -1511,21 +1638,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
@@ -1608,9 +1738,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
         }
       });
     }
-    const keys = Object.keys((0, import_get8.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys((0, import_get8.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
-    keys.forEach((key) => {
+    keys2.forEach((key) => {
       const formValue = (0, import_get8.default)(data, key);
       let oldKeyedSchema = (0, import_get8.default)(oldSchema, [PROPERTIES_KEY, key], {});
       let newKeyedSchema = (0, import_get8.default)(newSchema, [PROPERTIES_KEY, key], {});
@@ -1727,11 +1857,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 
 // src/schema/toIdSchema.ts
 var import_get9 = __toESM(require("lodash/get"));
-var import_isEqual2 = __toESM(require("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) => (0, import_isEqual2.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
         validator,
@@ -1798,12 +1927,11 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 
 // src/schema/toPathSchema.ts
 var import_get10 = __toESM(require("lodash/get"));
-var import_isEqual3 = __toESM(require("lodash/isEqual"));
 var import_set2 = __toESM(require("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) => (0, import_isEqual3.default)(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
         validator,
@@ -2241,9 +2369,6 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
-// src/enumOptionsDeselectValue.ts
-var import_isEqual4 = __toESM(require("lodash/isEqual"));
-
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -2258,18 +2383,17 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !(0, import_isEqual4.default)(v, value));
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return (0, import_isEqual4.default)(value, selected) ? void 0 : selected;
+  return deepEquals(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsIsSelected.ts
-var import_isEqual5 = __toESM(require("lodash/isEqual"));
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => (0, import_isEqual5.default)(sel, value));
+    return selected.some((sel) => deepEquals(sel, value));
   }
-  return (0, import_isEqual5.default)(selected, value);
+  return deepEquals(selected, value);
 }
 
 // src/enumOptionsIndexForValue.ts
@@ -2282,10 +2406,10 @@ function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false)
 }
 
 // src/enumOptionsSelectValue.ts
-var import_isNil = __toESM(require("lodash/isNil"));
+var import_isNil2 = __toESM(require("lodash/isNil"));
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!(0, import_isNil.default)(value)) {
+  if (!(0, import_isNil2.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));
@@ -2615,9 +2739,9 @@ function hasWidget(schema, widget, registeredWidgets = {}) {
 }
 
 // src/idGenerators.ts
-var import_isString3 = __toESM(require("lodash/isString"));
+var import_isString4 = __toESM(require("lodash/isString"));
 function idGenerator(id, suffix) {
-  const theId = (0, import_isString3.default)(id) ? id : id[ID_KEY];
+  const theId = (0, import_isString4.default)(id) ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 function descriptionId(id) {
@@ -2653,61 +2777,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)) {
@@ -2929,6 +2998,29 @@ function withIdRefPrefix(schemaNode) {
   return schemaNode;
 }
 
+// src/getChangedFields.ts
+var import_keys = __toESM(require("lodash/keys"));
+var import_pickBy = __toESM(require("lodash/pickBy"));
+var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"));
+var import_get13 = __toESM(require("lodash/get"));
+var import_difference = __toESM(require("lodash/difference"));
+function getChangedFields(a, b) {
+  const aIsPlainObject = (0, import_isPlainObject4.default)(a);
+  const bIsPlainObject = (0, import_isPlainObject4.default)(b);
+  if (a === b || !aIsPlainObject && !bIsPlainObject) {
+    return [];
+  }
+  if (aIsPlainObject && !bIsPlainObject) {
+    return (0, import_keys.default)(a);
+  } else if (!aIsPlainObject && bIsPlainObject) {
+    return (0, import_keys.default)(b);
+  } else {
+    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get13.default)(b, key))));
+    const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
+    return [...unequalFields, ...diffFields];
+  }
+}
+
 // src/enums.ts
 var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["ArrayItemTitle"] = "Item";
@@ -2965,11 +3057,9 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 
 // src/parser/schemaParser.ts
 var import_forEach = __toESM(require("lodash/forEach"));
-var import_isEqual7 = __toESM(require("lodash/isEqual"));
 
 // src/parser/ParserValidator.ts
-var import_get13 = __toESM(require("lodash/get"));
-var import_isEqual6 = __toESM(require("lodash/isEqual"));
+var import_get14 = __toESM(require("lodash/get"));
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2995,12 +3085,12 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get13.default)(schema, ID_KEY, hash);
+    const key = (0, import_get14.default)(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!(0, import_isEqual6.default)(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(
@@ -3022,7 +3112,7 @@ var ParserValidator = class {
    * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!(0, import_isEqual6.default)(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));
@@ -3062,7 +3152,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) => (0, import_isEqual7.default)(item, schema2));
+    const sameSchemaIndex = recurseList.findIndex((item) => deepEquals(item, schema2));
     if (sameSchemaIndex === -1) {
       recurseList.push(schema2);
       const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);