@rjsf/utils 5.22.3 → 5.23.0

package/dist/utils.esm.js

@@ -556,7 +556,7 @@ function resolveAllReferences(schema, rootSchema, recurseList) {
   }
   return isEqual(schema, resolvedSchema) ? schema : resolvedSchema;
 }
-function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
+function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
   const schema = {
     ...theSchema,
     properties: { ...theSchema.properties }
@@ -573,7 +573,8 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
           validator,
           { $ref: get4(schema.additionalProperties, [REF_KEY]) },
           rootSchema,
-          formData
+          formData,
+          experimental_customMergeAllOf
         );
       } else if ("type" in schema.additionalProperties) {
         additionalProperties = { ...schema.additionalProperties };
@@ -603,7 +604,8 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     rootSchema,
     expandAllBranches,
     recurseList,
-    rawFormData
+    rawFormData,
+    experimental_customMergeAllOf
   );
   return resolvedSchemas.flatMap((s) => {
     let resolvedSchema = s;
@@ -650,7 +652,13 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     }
     const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
     if (hasAdditionalProperties) {
-      return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData);
+      return stubExistingAdditionalProperties(
+        validator,
+        resolvedSchema,
+        rootSchema,
+        rawFormData,
+        experimental_customMergeAllOf
+      );
     }
     return resolvedSchema;
   });
@@ -835,7 +843,7 @@ var JUNK_OPTION = {
     }
   }
 };
-function calculateIndexScore(validator, rootSchema, schema, formData) {
+function calculateIndexScore(validator, rootSchema, schema, formData, experimental_customMergeAllOf) {
   let totalScore = 0;
   if (schema) {
     if (isObject2(schema.properties)) {
@@ -847,8 +855,20 @@ function calculateIndexScore(validator, rootSchema, schema, formData) {
             return score;
           }
           if (has2(value, REF_KEY)) {
-            const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
-            return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
+            const newSchema = retrieveSchema(
+              validator,
+              value,
+              rootSchema,
+              formValue,
+              experimental_customMergeAllOf
+            );
+            return score + calculateIndexScore(
+              validator,
+              rootSchema,
+              newSchema,
+              formValue || {},
+              experimental_customMergeAllOf
+            );
           }
           if ((has2(value, ONE_OF_KEY) || has2(value, ANY_OF_KEY)) && formValue) {
             const key2 = has2(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
@@ -859,14 +879,15 @@ function calculateIndexScore(validator, rootSchema, schema, formData) {
               formValue,
               get5(value, key2),
               -1,
-              discriminator
+              discriminator,
+              experimental_customMergeAllOf
             );
           }
           if (value.type === "object") {
             if (isObject2(formValue)) {
               score += 1;
             }
-            return score + calculateIndexScore(validator, rootSchema, value, formValue);
+            return score + calculateIndexScore(validator, rootSchema, value, formValue, experimental_customMergeAllOf);
           }
           if (value.type === guessType(formValue)) {
             let newScore = score + 1;
@@ -887,7 +908,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData) {
   }
   return totalScore;
 }
-function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) {
+function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField, experimental_customMergeAllOf) {
   const resolvedOptions = options.map((option) => {
     return resolveAllReferences(option, rootSchema, []);
   });
@@ -914,7 +935,7 @@ function getClosestMatchingOption(validator, rootSchema, formData, options, sele
     (scoreData, index) => {
       const { bestScore } = scoreData;
       const option = resolvedOptions[index];
-      const score = calculateIndexScore(validator, rootSchema, option, formData);
+      const score = calculateIndexScore(validator, rootSchema, option, formData, experimental_customMergeAllOf);
       scoreCount.add(score);
       if (score > bestScore) {
         return { bestIndex: index, bestScore: score };
@@ -1003,8 +1024,8 @@ function isConstant(schema) {
 }
 
 // src/schema/isSelect.ts
-function isSelect(validator, theSchema, rootSchema = {}) {
-  const schema = retrieveSchema(validator, theSchema, rootSchema, void 0);
+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;
@@ -1016,14 +1037,15 @@ function isSelect(validator, theSchema, rootSchema = {}) {
 }
 
 // src/schema/isMultiSelect.ts
-function isMultiSelect(validator, schema, rootSchema) {
+function isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) {
   if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
     return false;
   }
-  return isSelect(validator, schema.items, rootSchema);
+  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) {
   if (idx >= 0) {
     if (Array.isArray(schema.items) && idx < schema.items.length) {
@@ -1079,8 +1101,9 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   const schema = isObject(rawSchema) ? rawSchema : {};
   let defaults = parentDefaults;
   let schemaToCompute = null;
+  let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
-  if (isConstant(schema)) {
+  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never") {
     defaults = schema.const;
   } else if (isObject(defaults) && isObject(schema.default)) {
     defaults = mergeObjects(defaults, schema.default);
@@ -1114,6 +1137,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
         includeUndefinedValues,
         _recurseList,
         experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
         parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : void 0,
         rawFormData: formData,
         required
@@ -1125,13 +1149,18 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       return void 0;
     }
     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" };
+    }
     schemaToCompute = oneOf[getClosestMatchingOption(
       validator,
       rootSchema,
       isEmpty(formData) ? void 0 : formData,
       oneOf,
       0,
-      discriminator
+      discriminator,
+      experimental_customMergeAllOf
     )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   } else if (ANY_OF_KEY in schema) {
@@ -1146,7 +1175,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       isEmpty(formData) ? void 0 : formData,
       anyOf,
       0,
-      discriminator
+      discriminator,
+      experimental_customMergeAllOf
     )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   }
@@ -1155,7 +1185,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       rootSchema,
       includeUndefinedValues,
       _recurseList: updatedRecurseList,
-      experimental_defaultFormStateBehavior,
+      experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
+      experimental_customMergeAllOf,
       parentDefaults: defaults,
       rawFormData: formData,
       required
@@ -1185,7 +1216,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;
+        const hasConst = (isObject(propertySchema) && CONST_KEY in propertySchema || hasParentConst) && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
         const computedDefault = computeDefaults(validator, propertySchema, {
           rootSchema,
           _recurseList,
@@ -1226,6 +1257,7 @@ function getObjectDefaults(validator, rawSchema, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
           parentDefaults: get7(defaults, [key]),
           rawFormData: get7(formData, [key]),
@@ -1249,13 +1281,17 @@ function getArrayDefaults(validator, rawSchema, {
   rootSchema = {},
   _recurseList = [],
   experimental_defaultFormStateBehavior = void 0,
+  experimental_customMergeAllOf = void 0,
   required
 } = {}, defaults) {
   const schema = rawSchema;
-  const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
-  const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
+  const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
+  const { populate: arrayMinItemsPopulate, mergeExtraDefaults: arrayMergeExtraDefaults } = arrayMinItemsStateBehavior;
+  const neverPopulate = arrayMinItemsPopulate === "never";
+  const ignoreMinItemsFlagSet = arrayMinItemsPopulate === "requiredOnly";
+  const isPopulateAll = arrayMinItemsPopulate === "all" || !neverPopulate && !ignoreMinItemsFlagSet;
+  const computeSkipPopulate = arrayMinItemsStateBehavior?.computeSkipPopulate ?? (() => false);
   const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === "skipEmptyDefaults";
-  const computeSkipPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.computeSkipPopulate ?? (() => false);
   const emptyDefault = isSkipEmptyDefaults ? void 0 : [];
   if (Array.isArray(defaults)) {
     defaults = defaults.map((item, idx) => {
@@ -1264,6 +1300,7 @@ function getArrayDefaults(validator, rawSchema, {
         rootSchema,
         _recurseList,
         experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
         parentDefaults: item,
         required
       });
@@ -1274,19 +1311,22 @@ function getArrayDefaults(validator, rawSchema, {
     if (neverPopulate) {
       defaults = rawFormData;
     } else {
-      defaults = rawFormData.map((item, idx) => {
+      const itemDefaults = rawFormData.map((item, idx) => {
         return computeDefaults(validator, schemaItem, {
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
+          experimental_customMergeAllOf,
           rawFormData: item,
           parentDefaults: get7(defaults, [idx]),
           required
         });
       });
+      const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
+      defaults = mergeDefaultsWithFormData(defaults, itemDefaults, mergeExtraDefaults);
     }
   }
-  const hasConst = isObject(schema) && CONST_KEY in schema;
+  const hasConst = isObject(schema) && CONST_KEY in schema && experimental_defaultFormStateBehavior?.constAsDefaults !== "never";
   if (hasConst === false) {
     if (neverPopulate) {
       return defaults ?? emptyDefault;
@@ -1296,7 +1336,7 @@ function getArrayDefaults(validator, rawSchema, {
     }
   }
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-  if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+  if (!schema.minItems || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
     return defaults ? defaults : emptyDefault;
   }
   const defaultEntries = defaults || [];
@@ -1308,6 +1348,7 @@ function getArrayDefaults(validator, rawSchema, {
       rootSchema,
       _recurseList,
       experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf,
       required
     })
   );
@@ -1360,25 +1401,31 @@ function isCustomWidget(uiSchema = {}) {
 }
 
 // src/schema/isFilesArray.ts
-function isFilesArray(validator, schema, uiSchema = {}, rootSchema) {
+function isFilesArray(validator, schema, uiSchema = {}, rootSchema, experimental_customMergeAllOf) {
   if (uiSchema[UI_WIDGET_KEY] === "files") {
     return true;
   }
   if (schema.items) {
-    const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
+    const itemsSchema = retrieveSchema(
+      validator,
+      schema.items,
+      rootSchema,
+      void 0,
+      experimental_customMergeAllOf
+    );
     return itemsSchema.type === "string" && itemsSchema.format === "data-url";
   }
   return false;
 }
 
 // src/schema/getDisplayLabel.ts
-function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions) {
+function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions, experimental_customMergeAllOf) {
   const uiOptions = getUiOptions(uiSchema, globalOptions);
   const { label = true } = uiOptions;
   let displayLabel = !!label;
   const schemaType = getSchemaType(schema);
   if (schemaType === "array") {
-    displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
+    displayLabel = isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || isFilesArray(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) || isCustomWidget(uiSchema);
   }
   if (schemaType === "object") {
     displayLabel = false;
@@ -1412,7 +1459,7 @@ function mergeValidationData(validator, validationData, additionalErrorSchema) {
 import get8 from "lodash/get";
 import has3 from "lodash/has";
 var NO_VALUE = Symbol("no Value");
-function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
+function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
   let newFormData;
   if (has3(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
@@ -1431,10 +1478,22 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       let oldKeyedSchema = get8(oldSchema, [PROPERTIES_KEY, key], {});
       let newKeyedSchema = get8(newSchema, [PROPERTIES_KEY, key], {});
       if (has3(oldKeyedSchema, REF_KEY)) {
-        oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
+        oldKeyedSchema = retrieveSchema(
+          validator,
+          oldKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
       if (has3(newKeyedSchema, REF_KEY)) {
-        newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
+        newKeyedSchema = retrieveSchema(
+          validator,
+          newKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf
+        );
       }
       const oldSchemaTypeForKey = get8(oldKeyedSchema, "type");
       const newSchemaTypeForKey = get8(newKeyedSchema, "type");
@@ -1448,7 +1507,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             rootSchema,
             newKeyedSchema,
             oldKeyedSchema,
-            formValue
+            formValue,
+            experimental_customMergeAllOf
           );
           if (itemData !== void 0 || newSchemaTypeForKey === "array") {
             nestedData[key] = itemData;
@@ -1481,10 +1541,22 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
     let newSchemaItems = get8(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if (has3(oldSchemaItems, REF_KEY)) {
-        oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
+        oldSchemaItems = retrieveSchema(
+          validator,
+          oldSchemaItems,
+          rootSchema,
+          data,
+          experimental_customMergeAllOf
+        );
       }
       if (has3(newSchemaItems, REF_KEY)) {
-        newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
+        newSchemaItems = retrieveSchema(
+          validator,
+          newSchemaItems,
+          rootSchema,
+          data,
+          experimental_customMergeAllOf
+        );
       }
       const oldSchemaType = get8(oldSchemaItems, "type");
       const newSchemaType = get8(newSchemaItems, "type");
@@ -1497,7 +1569,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
               rootSchema,
               newSchemaItems,
               oldSchemaItems,
-              aValue
+              aValue,
+              experimental_customMergeAllOf
             );
             if (itemValue !== void 0 && (maxItems < 0 || newValue.length < maxItems)) {
               newValue.push(itemValue);
@@ -1520,7 +1593,7 @@ 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);
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
     const sameSchemaIndex = _recurseList.findIndex((item) => isEqual2(item, _schema));
     if (sameSchemaIndex === -1) {
       return toIdSchemaInternal(
@@ -1590,9 +1663,9 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 import get10 from "lodash/get";
 import isEqual3 from "lodash/isEqual";
 import set2 from "lodash/set";
-function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
+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);
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
     const sameSchemaIndex = _recurseList.findIndex((item) => isEqual3(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal(
@@ -1601,7 +1674,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         name,
         rootSchema,
         formData,
-        _recurseList.concat(_schema)
+        _recurseList.concat(_schema),
+        experimental_customMergeAllOf
       );
     }
   }
@@ -1611,11 +1685,27 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
   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);
+    const index = getClosestMatchingOption(
+      validator,
+      rootSchema,
+      formData,
+      xxxOf,
+      0,
+      discriminator,
+      experimental_customMergeAllOf
+    );
     const _schema = xxxOf[index];
     pathSchema = {
       ...pathSchema,
-      ...toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList)
+      ...toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList,
+        experimental_customMergeAllOf
+      )
     };
   }
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
@@ -1632,7 +1722,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf
           );
         } else if (schemaAdditionalItems) {
           pathSchema[i] = toPathSchemaInternal(
@@ -1641,7 +1732,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf
           );
         } else {
           console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
@@ -1655,7 +1747,8 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
           `${name}.${i}`,
           rootSchema,
           element,
-          _recurseList
+          _recurseList,
+          experimental_customMergeAllOf
         );
       });
     }
@@ -1670,14 +1763,15 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         // 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
         get10(formData, [property]),
-        _recurseList
+        _recurseList,
+        experimental_customMergeAllOf
       );
     }
   }
   return pathSchema;
 }
-function toPathSchema(validator, schema, name = "", rootSchema, formData) {
-  return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
+function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
 }
 
 // src/createSchemaUtils.ts
@@ -1748,7 +1842,14 @@ var SchemaUtils = class {
    * @returns - True if the label should be displayed or false if it should not
    */
   getDisplayLabel(schema, uiSchema, globalOptions) {
-    return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
+    return getDisplayLabel(
+      this.validator,
+      schema,
+      uiSchema,
+      this.rootSchema,
+      globalOptions,
+      this.experimental_customMergeAllOf
+    );
   }
   /** Determines which of the given `options` provided most closely matches the `formData`.
    * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
@@ -1770,7 +1871,8 @@ var SchemaUtils = class {
       formData,
       options,
       selectedOption,
-      discriminatorField
+      discriminatorField,
+      this.experimental_customMergeAllOf
     );
   }
   /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
@@ -1805,7 +1907,7 @@ var SchemaUtils = class {
    * @returns - True if schema/uiSchema contains an array of files, otherwise false
    */
   isFilesArray(schema, uiSchema) {
-    return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
+    return isFilesArray(this.validator, schema, uiSchema, this.rootSchema, this.experimental_customMergeAllOf);
   }
   /** Checks to see if the `schema` combination represents a multi-select
    *
@@ -1813,7 +1915,7 @@ var SchemaUtils = class {
    * @returns - True if schema contains a multi-select, otherwise false
    */
   isMultiSelect(schema) {
-    return isMultiSelect(this.validator, schema, this.rootSchema);
+    return isMultiSelect(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
   }
   /** Checks to see if the `schema` combination represents a select
    *
@@ -1821,7 +1923,7 @@ var SchemaUtils = class {
    * @returns - True if schema contains a select, otherwise false
    */
   isSelect(schema) {
-    return isSelect(this.validator, schema, this.rootSchema);
+    return isSelect(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
   }
   /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
    * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
@@ -1866,7 +1968,14 @@ var SchemaUtils = class {
    *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
    */
   sanitizeDataForNewSchema(newSchema, oldSchema, data) {
-    return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+    return sanitizeDataForNewSchema(
+      this.validator,
+      this.rootSchema,
+      newSchema,
+      oldSchema,
+      data,
+      this.experimental_customMergeAllOf
+    );
   }
   /** Generates an `IdSchema` object for the `schema`, recursively
    *
@@ -1897,7 +2006,14 @@ var SchemaUtils = class {
    * @returns - The `PathSchema` object for the `schema`
    */
   toPathSchema(schema, name, formData) {
-    return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
+    return toPathSchema(
+      this.validator,
+      schema,
+      name,
+      this.rootSchema,
+      formData,
+      this.experimental_customMergeAllOf
+    );
   }
 };
 function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}, experimental_customMergeAllOf) {
@@ -2104,9 +2220,9 @@ var ErrorSchemaBuilder = class {
       errorBlock[ERRORS_KEY] = errorsList;
     }
     if (Array.isArray(errorOrList)) {
-      errorsList.push(...errorOrList);
+      set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, ...errorOrList])]);
     } else {
-      errorsList.push(errorOrList);
+      set3(errorBlock, ERRORS_KEY, [.../* @__PURE__ */ new Set([...errorsList, errorOrList])]);
     }
     return this;
   }
@@ -2120,7 +2236,7 @@ var ErrorSchemaBuilder = class {
    */
   setErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
+    const listToAdd = Array.isArray(errorOrList) ? [.../* @__PURE__ */ new Set([...errorOrList])] : [errorOrList];
     set3(errorBlock, ERRORS_KEY, listToAdd);
     return this;
   }