@rjsf/utils 5.24.10 → 6.0.0-beta.1

package/dist/utils.esm.js

@@ -59,11 +59,15 @@ var ITEMS_KEY = "items";
 var JUNK_OPTION_ID = "_$junk_option_schema_id$_";
 var NAME_KEY = "$name";
 var ONE_OF_KEY = "oneOf";
+var PATTERN_PROPERTIES_KEY = "patternProperties";
 var PROPERTIES_KEY = "properties";
+var READONLY_KEY = "readonly";
 var REQUIRED_KEY = "required";
 var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
 var REF_KEY = "$ref";
-var RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+var DISCRIMINATOR_PATH = ["discriminator", "propertyName"];
+var FORM_CONTEXT_NAME = "formContext";
+var LOOKUP_MAP_NAME = "layoutGridLookupMap";
 var RJSF_ADDITIONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
 var ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
 var UI_FIELD_KEY = "ui:field";
@@ -91,7 +95,7 @@ function getUiOptions(uiSchema = {}, globalOptions = {}) {
 
 // src/canExpand.ts
 function canExpand(schema, uiSchema = {}, formData) {
-  if (!schema.additionalProperties) {
+  if (!(schema.additionalProperties || schema.patternProperties)) {
     return false;
   }
   const { expandable = true } = getUiOptions(uiSchema);
@@ -141,9 +145,23 @@ function deepEquals(a, b) {
   });
 }
 
-// src/schema/getDefaultFormState.ts
+// src/schema/findFieldInSchema.ts
 import get7 from "lodash/get";
-import isEmpty from "lodash/isEmpty";
+import has3 from "lodash/has";
+
+// src/schema/findSelectedOptionInXxxOf.ts
+import get5 from "lodash/get";
+import isEqual from "lodash/isEqual";
+
+// src/schema/retrieveSchema.ts
+import get4 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 mergeAllOf from "json-schema-merge-allof";
 
 // src/findSchemaDefinition.ts
 import jsonpointer from "jsonpointer";
@@ -189,113 +207,12 @@ function findSchemaDefinition($ref, rootSchema = {}) {
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
 }
 
-// src/schema/getClosestMatchingOption.ts
-import get5 from "lodash/get";
-import has2 from "lodash/has";
-import isNumber2 from "lodash/isNumber";
-import isObject2 from "lodash/isObject";
-import isString2 from "lodash/isString";
-import reduce from "lodash/reduce";
-import times2 from "lodash/times";
-
-// src/schema/getMatchingOption.ts
-import get2 from "lodash/get";
-import has from "lodash/has";
-import isNumber from "lodash/isNumber";
-
-// src/getOptionMatchingSimpleDiscriminator.ts
-import get from "lodash/get";
-function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
-  if (formData && discriminatorField) {
-    const value = get(formData, discriminatorField);
-    if (value === void 0) {
-      return;
-    }
-    for (let i = 0; i < options.length; i++) {
-      const option = options[i];
-      const discriminator = get(option, [PROPERTIES_KEY, discriminatorField], {});
-      if (discriminator.type === "object" || discriminator.type === "array") {
-        continue;
-      }
-      if (discriminator.const === value) {
-        return i;
-      }
-      if (discriminator.enum?.includes(value)) {
-        return i;
-      }
-    }
-  }
-  return;
-}
-
-// src/schema/getMatchingOption.ts
-function getMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
-  if (formData === void 0) {
-    return 0;
-  }
-  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-  if (isNumber(simpleDiscriminatorMatch)) {
-    return simpleDiscriminatorMatch;
-  }
-  for (let i = 0; i < options.length; i++) {
-    const option = options[i];
-    if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = get2(formData, discriminatorField);
-      const discriminator = get2(option, [PROPERTIES_KEY, discriminatorField], {});
-      if (validator.isValid(discriminator, value, rootSchema)) {
-        return i;
-      }
-    } else if (option[PROPERTIES_KEY]) {
-      const requiresAnyOf = {
-        anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
-          required: [key]
-        }))
-      };
-      let augmentedSchema;
-      if (option.anyOf) {
-        const { ...shallowClone } = option;
-        if (!shallowClone.allOf) {
-          shallowClone.allOf = [];
-        } else {
-          shallowClone.allOf = shallowClone.allOf.slice();
-        }
-        shallowClone.allOf.push(requiresAnyOf);
-        augmentedSchema = shallowClone;
-      } else {
-        augmentedSchema = Object.assign({}, option, requiresAnyOf);
-      }
-      delete augmentedSchema.required;
-      if (validator.isValid(augmentedSchema, formData, rootSchema)) {
-        return i;
-      }
-    } else if (validator.isValid(option, formData, rootSchema)) {
-      return i;
-    }
-  }
-  return 0;
-}
-
-// src/schema/getFirstMatchingOption.ts
-function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
-  return getMatchingOption(validator, formData, options, rootSchema, discriminatorField);
-}
-
-// src/schema/retrieveSchema.ts
-import get4 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 mergeAllOf from "json-schema-merge-allof";
-
 // src/getDiscriminatorFieldFromSchema.ts
-import get3 from "lodash/get";
+import get from "lodash/get";
 import isString from "lodash/isString";
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = get3(schema, "discriminator.propertyName", void 0);
+  const maybeString = get(schema, DISCRIMINATOR_PATH);
   if (isString(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== void 0) {
@@ -339,7 +256,7 @@ function getSchemaType(schema) {
   if (!type && schema.enum) {
     return "string";
   }
-  if (!type && (schema.properties || schema.additionalProperties)) {
+  if (!type && (schema.properties || schema.additionalProperties || schema.patternProperties)) {
     return "object";
   }
   if (Array.isArray(type)) {
@@ -368,7 +285,85 @@ function mergeSchemas(obj1, obj2) {
   }, acc);
 }
 
+// src/schema/getFirstMatchingOption.ts
+import get3 from "lodash/get";
+import has from "lodash/has";
+import isNumber from "lodash/isNumber";
+
+// src/getOptionMatchingSimpleDiscriminator.ts
+import get2 from "lodash/get";
+function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
+  if (formData && discriminatorField) {
+    const value = get2(formData, discriminatorField);
+    if (value === void 0) {
+      return;
+    }
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      const discriminator = get2(option, [PROPERTIES_KEY, discriminatorField], {});
+      if (discriminator.type === "object" || discriminator.type === "array") {
+        continue;
+      }
+      if (discriminator.const === value) {
+        return i;
+      }
+      if (discriminator.enum?.includes(value)) {
+        return i;
+      }
+    }
+  }
+  return;
+}
+
+// src/schema/getFirstMatchingOption.ts
+function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
+  if (formData === void 0) {
+    return 0;
+  }
+  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+  if (isNumber(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
+  for (let i = 0; i < options.length; i++) {
+    const option = options[i];
+    if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
+      const value = get3(formData, discriminatorField);
+      const discriminator = get3(option, [PROPERTIES_KEY, discriminatorField], {});
+      if (validator.isValid(discriminator, value, rootSchema)) {
+        return i;
+      }
+    } else if (option[PROPERTIES_KEY]) {
+      const requiresAnyOf = {
+        anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
+          required: [key]
+        }))
+      };
+      let augmentedSchema;
+      if (option.anyOf) {
+        const { ...shallowClone } = option;
+        if (!shallowClone.allOf) {
+          shallowClone.allOf = [];
+        } else {
+          shallowClone.allOf = shallowClone.allOf.slice();
+        }
+        shallowClone.allOf.push(requiresAnyOf);
+        augmentedSchema = shallowClone;
+      } else {
+        augmentedSchema = Object.assign({}, option, requiresAnyOf);
+      }
+      delete augmentedSchema.required;
+      if (validator.isValid(augmentedSchema, formData, rootSchema)) {
+        return i;
+      }
+    } else if (validator.isValid(option, formData, rootSchema)) {
+      return i;
+    }
+  }
+  return 0;
+}
+
 // src/schema/retrieveSchema.ts
+import isEmpty from "lodash/isEmpty";
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf) {
   return retrieveSchemaInternal(
     validator,
@@ -457,6 +452,15 @@ function getAllPermutationsOfXxxOf(listOfLists) {
   );
   return allPermutations;
 }
+function getMatchingPatternProperties(schema, key) {
+  return Object.keys(schema.patternProperties).filter((pattern) => RegExp(pattern).test(key)).reduce(
+    (obj, pattern) => {
+      set(obj, [pattern], schema.patternProperties[pattern]);
+      return obj;
+    },
+    {}
+  );
+}
 function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   const updatedSchemas = resolveReference(
     validator,
@@ -571,31 +575,50 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
     if (key in schema.properties) {
       return;
     }
-    let additionalProperties = {};
-    if (typeof schema.additionalProperties !== "boolean") {
-      if (REF_KEY in schema.additionalProperties) {
-        additionalProperties = retrieveSchema(
+    if (PATTERN_PROPERTIES_KEY in schema) {
+      const matchingProperties = getMatchingPatternProperties(schema, key);
+      if (!isEmpty(matchingProperties)) {
+        schema.properties[key] = retrieveSchema(
           validator,
-          { $ref: get4(schema.additionalProperties, [REF_KEY]) },
+          { allOf: Object.values(matchingProperties) },
           rootSchema,
           formData,
           experimental_customMergeAllOf
         );
-      } else if ("type" in schema.additionalProperties) {
-        additionalProperties = { ...schema.additionalProperties };
-      } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
-        additionalProperties = {
-          type: "object",
-          ...schema.additionalProperties
-        };
+        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        return;
+      }
+    }
+    if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
+      let additionalProperties = {};
+      if (typeof schema.additionalProperties !== "boolean") {
+        if (REF_KEY in schema.additionalProperties) {
+          additionalProperties = retrieveSchema(
+            validator,
+            { $ref: get4(schema.additionalProperties, [REF_KEY]) },
+            rootSchema,
+            formData,
+            experimental_customMergeAllOf
+          );
+        } else if ("type" in schema.additionalProperties) {
+          additionalProperties = { ...schema.additionalProperties };
+        } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
+          additionalProperties = {
+            type: "object",
+            ...schema.additionalProperties
+          };
+        } else {
+          additionalProperties = { type: guessType(get4(formData, [key])) };
+        }
       } else {
         additionalProperties = { type: guessType(get4(formData, [key])) };
       }
+      schema.properties[key] = additionalProperties;
+      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     } else {
-      additionalProperties = { type: guessType(get4(formData, [key])) };
+      schema.properties[key] = { type: "null" };
+      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
     }
-    schema.properties[key] = additionalProperties;
-    set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
   });
   return schema;
 }
@@ -655,7 +678,28 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
         return resolvedSchemaWithoutAllOf;
       }
     }
-    const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
+    if (PROPERTIES_KEY in resolvedSchema && PATTERN_PROPERTIES_KEY in resolvedSchema) {
+      resolvedSchema = Object.keys(resolvedSchema.properties).reduce(
+        (schema2, key) => {
+          const matchingProperties = getMatchingPatternProperties(schema2, key);
+          if (!isEmpty(matchingProperties)) {
+            schema2.properties[key] = retrieveSchema(
+              validator,
+              { allOf: [schema2.properties[key], ...Object.values(matchingProperties)] },
+              rootSchema,
+              rawFormData,
+              experimental_customMergeAllOf
+            );
+          }
+          return schema2;
+        },
+        {
+          ...resolvedSchema,
+          properties: { ...resolvedSchema.properties }
+        }
+      );
+    }
+    const hasAdditionalProperties = PATTERN_PROPERTIES_KEY in resolvedSchema || ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false;
     if (hasAdditionalProperties) {
       return stubExistingAdditionalProperties(
         validator,
@@ -838,7 +882,159 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
   });
 }
 
+// src/schema/findSelectedOptionInXxxOf.ts
+function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField, xxx, formData = {}, experimental_customMergeAllOf) {
+  if (Array.isArray(schema[xxx])) {
+    const discriminator = getDiscriminatorFieldFromSchema(schema);
+    const selectorField = discriminator || fallbackField;
+    const xxxOfs = schema[xxx].map(
+      (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
+    );
+    const data = get5(formData, selectorField);
+    if (data !== void 0) {
+      return xxxOfs.find((xxx2) => {
+        return isEqual(
+          get5(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get5(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+          data
+        );
+      });
+    }
+  }
+  return void 0;
+}
+
+// src/schema/getFromSchema.ts
+import get6 from "lodash/get";
+import has2 from "lodash/has";
+import isEmpty2 from "lodash/isEmpty";
+function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
+  let fieldSchema = schema;
+  if (has2(schema, REF_KEY)) {
+    fieldSchema = retrieveSchema(validator, schema, rootSchema, void 0, experimental_customMergeAllOf);
+  }
+  if (isEmpty2(path)) {
+    return fieldSchema;
+  }
+  const pathList = Array.isArray(path) ? path : path.split(".");
+  const [part, ...nestedPath] = pathList;
+  if (part && has2(fieldSchema, part)) {
+    fieldSchema = get6(fieldSchema, part);
+    return getFromSchemaInternal(
+      validator,
+      rootSchema,
+      fieldSchema,
+      nestedPath,
+      experimental_customMergeAllOf
+    );
+  }
+  return void 0;
+}
+function getFromSchema(validator, rootSchema, schema, path, defaultValue, experimental_customMergeAllOf) {
+  const result = getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf);
+  if (result === void 0) {
+    return defaultValue;
+  }
+  return result;
+}
+
+// src/schema/findFieldInSchema.ts
+var NOT_FOUND_SCHEMA = { title: "!@#$_UNKNOWN_$#@!" };
+function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, experimental_customMergeAllOf) {
+  const pathList = Array.isArray(path) ? [...path] : path.split(".");
+  let parentField = schema;
+  const fieldName = pathList.pop();
+  if (pathList.length) {
+    pathList.forEach((subPath) => {
+      parentField = getFromSchema(
+        validator,
+        rootSchema,
+        parentField,
+        [PROPERTIES_KEY, subPath],
+        {},
+        experimental_customMergeAllOf
+      );
+      if (has3(parentField, ONE_OF_KEY)) {
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ONE_OF_KEY,
+          get7(formData, subPath),
+          experimental_customMergeAllOf
+        );
+      } else if (has3(parentField, ANY_OF_KEY)) {
+        parentField = findSelectedOptionInXxxOf(
+          validator,
+          rootSchema,
+          parentField,
+          fieldName,
+          ANY_OF_KEY,
+          get7(formData, subPath),
+          experimental_customMergeAllOf
+        );
+      }
+    });
+  }
+  if (has3(parentField, ONE_OF_KEY)) {
+    parentField = findSelectedOptionInXxxOf(
+      validator,
+      rootSchema,
+      parentField,
+      fieldName,
+      ONE_OF_KEY,
+      formData,
+      experimental_customMergeAllOf
+    );
+  } else if (has3(parentField, ANY_OF_KEY)) {
+    parentField = findSelectedOptionInXxxOf(
+      validator,
+      rootSchema,
+      parentField,
+      fieldName,
+      ANY_OF_KEY,
+      formData,
+      experimental_customMergeAllOf
+    );
+  }
+  let field = getFromSchema(
+    validator,
+    rootSchema,
+    parentField,
+    [PROPERTIES_KEY, fieldName],
+    NOT_FOUND_SCHEMA,
+    experimental_customMergeAllOf
+  );
+  if (field === NOT_FOUND_SCHEMA) {
+    field = void 0;
+  }
+  const requiredArray = getFromSchema(
+    validator,
+    rootSchema,
+    parentField,
+    REQUIRED_KEY,
+    [],
+    experimental_customMergeAllOf
+  );
+  let isRequired;
+  if (field && Array.isArray(requiredArray)) {
+    isRequired = requiredArray.includes(fieldName);
+  }
+  return { field, isRequired };
+}
+
+// src/schema/getDefaultFormState.ts
+import get11 from "lodash/get";
+import isEmpty3 from "lodash/isEmpty";
+
 // src/schema/getClosestMatchingOption.ts
+import get8 from "lodash/get";
+import has4 from "lodash/has";
+import isNumber2 from "lodash/isNumber";
+import isObject2 from "lodash/isObject";
+import isString2 from "lodash/isString";
+import reduce from "lodash/reduce";
+import times2 from "lodash/times";
 var JUNK_OPTION = {
   type: "object",
   $id: JUNK_OPTION_ID,
@@ -855,11 +1051,11 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
       totalScore += reduce(
         schema.properties,
         (score, value, key) => {
-          const formValue = get5(formData, key);
+          const formValue = get8(formData, key);
           if (typeof value === "boolean") {
             return score;
           }
-          if (has2(value, REF_KEY)) {
+          if (has4(value, REF_KEY)) {
             const newSchema = retrieveSchema(
               validator,
               value,
@@ -875,14 +1071,14 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
               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;
+          if ((has4(value, ONE_OF_KEY) || has4(value, ANY_OF_KEY)) && formValue) {
+            const key2 = has4(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
             const discriminator = getDiscriminatorFieldFromSchema(value);
             return score + getClosestMatchingOption(
               validator,
               rootSchema,
               formValue,
-              get5(value, key2),
+              get8(value, key2),
               -1,
               discriminator,
               experimental_customMergeAllOf
@@ -961,7 +1157,7 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-import get6 from "lodash/get";
+import get9 from "lodash/get";
 import isNil from "lodash/isNil";
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
   if (Array.isArray(formData)) {
@@ -988,11 +1184,11 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
     return Object.keys(formData).reduce((acc2, key) => {
-      const keyValue = get6(formData, key);
+      const keyValue = get9(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? get6(defaults, key) : {},
+        defaults ? get9(defaults, key) : {},
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -1011,26 +1207,29 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
 
 // src/mergeObjects.ts
 function mergeObjects(obj1, obj2, concatArrays = false) {
-  return Object.keys(obj2).reduce((acc, key) => {
-    const left = obj1 ? obj1[key] : {}, right = obj2[key];
-    if (obj1 && key in obj1 && isObject(right)) {
-      acc[key] = mergeObjects(left, right, concatArrays);
-    } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
-      let toMerge = right;
-      if (concatArrays === "preventDuplicates") {
-        toMerge = right.reduce((result, value) => {
-          if (!left.includes(value)) {
-            result.push(value);
-          }
-          return result;
-        }, []);
+  return Object.keys(obj2).reduce(
+    (acc, key) => {
+      const left = obj1 ? obj1[key] : {}, right = obj2[key];
+      if (obj1 && key in obj1 && isObject(right)) {
+        acc[key] = mergeObjects(left, right, concatArrays);
+      } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
+        let toMerge = right;
+        if (concatArrays === "preventDuplicates") {
+          toMerge = right.reduce((result, value) => {
+            if (!left.includes(value)) {
+              result.push(value);
+            }
+            return result;
+          }, []);
+        }
+        acc[key] = left.concat(toMerge);
+      } else {
+        acc[key] = right;
       }
-      acc[key] = left.concat(toMerge);
-    } else {
-      acc[key] = right;
-    }
-    return acc;
-  }, Object.assign({}, obj1));
+      return acc;
+    },
+    Object.assign({}, obj1)
+  );
 }
 
 // src/isConstant.ts
@@ -1067,6 +1266,9 @@ function constIsAjvDataReference(schema) {
   return isObject(schemaConst) && isString3(schemaConst?.$data) && schemaType !== "object" && schemaType !== "array";
 }
 
+// src/optionsList.ts
+import get10 from "lodash/get";
+
 // src/toConstant.ts
 function toConstant(schema) {
   if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
@@ -1080,21 +1282,12 @@ function toConstant(schema) {
 
 // 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 };
@@ -1109,11 +1302,24 @@ function optionsList(schema, uiSchema) {
     altSchemas = schema.oneOf;
     altUiSchemas = uiSchema?.oneOf;
   }
+  let selectorField = getDiscriminatorFieldFromSchema(schema);
+  if (uiSchema) {
+    const { optionsSchemaSelector = selectorField } = getUiOptions(uiSchema);
+    selectorField = optionsSchemaSelector;
+  }
   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);
+    let value;
+    let label = title;
+    if (selectorField) {
+      const innerSchema = get10(aSchema, [PROPERTIES_KEY, selectorField], {});
+      value = get10(innerSchema, DEFAULT_KEY, get10(innerSchema, CONST_KEY));
+      label = label || innerSchema?.title || aSchema.title || String(value);
+    } else {
+      value = toConstant(aSchema);
+      label = label || aSchema.title || String(value);
+    }
     return {
       schema: aSchema,
       label,
@@ -1148,10 +1354,10 @@ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValu
     const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
     if (isObject(computedDefault)) {
       if (emptyObjectFields === "skipEmptyDefaults") {
-        if (!isEmpty(computedDefault)) {
+        if (!isEmpty3(computedDefault)) {
           obj[key] = computedDefault;
         }
-      } else if ((!isEmpty(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
+      } else if ((!isEmpty3(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
         obj[key] = computedDefault;
       }
     } else if (
@@ -1335,7 +1541,7 @@ function getObjectDefaults(validator, rawSchema, {
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc, key) => {
-        const propertySchema = get7(retrievedSchema, [PROPERTIES_KEY, key]);
+        const propertySchema = get11(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" && !constIsAjvDataReference(propertySchema);
         const computedDefault = computeDefaults(validator, propertySchema, {
@@ -1344,8 +1550,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get7(defaults, [key]),
-          rawFormData: get7(formData, [key]),
+          parentDefaults: get11(defaults, [key]),
+          rawFormData: get11(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData
         });
@@ -1381,8 +1587,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get7(defaults, [key]),
-          rawFormData: get7(formData, [key]),
+          parentDefaults: get11(defaults, [key]),
+          rawFormData: get11(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData
         });
@@ -1443,7 +1649,7 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           rawFormData: item,
-          parentDefaults: get7(defaults, [idx]),
+          parentDefaults: get11(defaults, [idx]),
           required,
           shouldMergeDefaultsIntoFormData
         });
@@ -1483,6 +1689,7 @@ function getArrayDefaults(validator, rawSchema, {
 }
 function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
   switch (getSchemaType(rawSchema)) {
+    // We need to recurse for object schema inner default values.
     case "object": {
       return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
     }
@@ -1569,45 +1776,29 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   return displayLabel;
 }
 
-// src/schema/mergeValidationData.ts
-import isEmpty2 from "lodash/isEmpty";
-function mergeValidationData(validator, validationData, additionalErrorSchema) {
-  if (!additionalErrorSchema) {
-    return validationData;
-  }
-  const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
-  let errors = validator.toErrorList(additionalErrorSchema);
-  let errorSchema = additionalErrorSchema;
-  if (!isEmpty2(oldErrorSchema)) {
-    errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
-    errors = [...oldErrors].concat(errors);
-  }
-  return { errorSchema, errors };
-}
-
 // src/schema/sanitizeDataForNewSchema.ts
-import get8 from "lodash/get";
-import has3 from "lodash/has";
+import get12 from "lodash/get";
+import has5 from "lodash/has";
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
   let newFormData;
-  if (has3(newSchema, PROPERTIES_KEY)) {
+  if (has5(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
-    if (has3(oldSchema, PROPERTIES_KEY)) {
-      const properties = get8(oldSchema, PROPERTIES_KEY, {});
+    if (has5(oldSchema, PROPERTIES_KEY)) {
+      const properties = get12(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
-        if (has3(data, key)) {
+        if (has5(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys(get8(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys(get12(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = get8(data, key);
-      let oldKeyedSchema = get8(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get8(newSchema, [PROPERTIES_KEY, key], {});
-      if (has3(oldKeyedSchema, REF_KEY)) {
+      const formValue = get12(data, key);
+      let oldKeyedSchema = get12(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get12(newSchema, [PROPERTIES_KEY, key], {});
+      if (has5(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
           oldKeyedSchema,
@@ -1616,7 +1807,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if (has3(newKeyedSchema, REF_KEY)) {
+      if (has5(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(
           validator,
           newKeyedSchema,
@@ -1625,10 +1816,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = get8(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = get8(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = get12(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get12(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-        if (has3(removeOldSchemaData, key)) {
+        if (has5(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
         }
         if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
@@ -1644,17 +1835,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = get8(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = get8(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = get12(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get12(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get8(newKeyedSchema, "readOnly") === true) {
+            } else if (get12(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get8(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = get8(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = get12(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get12(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -1666,11 +1857,11 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if (get8(oldSchema, "type") === "array" && get8(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = get8(oldSchema, "items");
-    let newSchemaItems = get8(newSchema, "items");
+  } else if (get12(oldSchema, "type") === "array" && get12(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get12(oldSchema, "items");
+    let newSchemaItems = get12(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
-      if (has3(oldSchemaItems, REF_KEY)) {
+      if (has5(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
           validator,
           oldSchemaItems,
@@ -1679,7 +1870,7 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      if (has3(newSchemaItems, REF_KEY)) {
+      if (has5(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(
           validator,
           newSchemaItems,
@@ -1688,10 +1879,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = get8(oldSchemaItems, "type");
-      const newSchemaType = get8(newSchemaItems, "type");
+      const oldSchemaType = get12(oldSchemaItems, "type");
+      const newSchemaType = get12(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get8(newSchema, "maxItems", -1);
+        const maxItems = get12(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -1719,58 +1910,60 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
 }
 
 // src/schema/toIdSchema.ts
-import get9 from "lodash/get";
+import get13 from "lodash/get";
 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) => deepEquals(item, _schema));
-    if (sameSchemaIndex === -1) {
+  const $id = id || idPrefix;
+  const idSchema = { $id };
+  if (typeof schema === "object") {
+    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) => deepEquals(item, _schema));
+      if (sameSchemaIndex === -1) {
+        return toIdSchemaInternal(
+          validator,
+          _schema,
+          idPrefix,
+          idSeparator,
+          id,
+          rootSchema,
+          formData,
+          _recurseList.concat(_schema),
+          experimental_customMergeAllOf
+        );
+      }
+    }
+    if (ITEMS_KEY in schema && !get13(schema, [ITEMS_KEY, REF_KEY])) {
       return toIdSchemaInternal(
         validator,
-        _schema,
+        get13(schema, ITEMS_KEY),
         idPrefix,
         idSeparator,
         id,
         rootSchema,
         formData,
-        _recurseList.concat(_schema),
-        experimental_customMergeAllOf
-      );
-    }
-  }
-  if (ITEMS_KEY in schema && !get9(schema, [ITEMS_KEY, REF_KEY])) {
-    return toIdSchemaInternal(
-      validator,
-      get9(schema, ITEMS_KEY),
-      idPrefix,
-      idSeparator,
-      id,
-      rootSchema,
-      formData,
-      _recurseList,
-      experimental_customMergeAllOf
-    );
-  }
-  const $id = id || idPrefix;
-  const idSchema = { $id };
-  if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
-    for (const name in schema.properties) {
-      const field = get9(schema, [PROPERTIES_KEY, name]);
-      const fieldId = idSchema[ID_KEY] + idSeparator + name;
-      idSchema[name] = toIdSchemaInternal(
-        validator,
-        isObject(field) ? field : {},
-        idPrefix,
-        idSeparator,
-        fieldId,
-        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
-        get9(formData, [name]),
         _recurseList,
         experimental_customMergeAllOf
       );
     }
+    if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
+      for (const name in schema.properties) {
+        const field = schema[PROPERTIES_KEY][name];
+        const fieldId = idSchema[ID_KEY] + idSeparator + name;
+        idSchema[name] = toIdSchemaInternal(
+          validator,
+          field,
+          idPrefix,
+          idSeparator,
+          fieldId,
+          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
+          get13(formData, [name]),
+          _recurseList,
+          experimental_customMergeAllOf
+        );
+      }
+    }
   }
   return idSchema;
 }
@@ -1789,7 +1982,7 @@ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "roo
 }
 
 // src/schema/toPathSchema.ts
-import get10 from "lodash/get";
+import get14 from "lodash/get";
 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) {
@@ -1882,7 +2075,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get10(schema, [PROPERTIES_KEY, property]);
+      const field = get14(schema, [PROPERTIES_KEY, property], {});
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -1890,7 +2083,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         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
-        get10(formData, [property]),
+        get14(formData, [property]),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -1940,6 +2133,47 @@ var SchemaUtils = class {
     }
     return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior) || this.experimental_customMergeAllOf !== experimental_customMergeAllOf;
   }
+  /** Finds the field specified by the `path` within the root or recursed `schema`. If there is no field for the specified
+   * `path`, then the default `{ field: undefined, isRequired: undefined }` is returned. It determines whether a leaf
+   * field is in the `required` list for its parent and if so, it is marked as required on return.
+   *
+   * @param schema - The current node within the JSON schema
+   * @param path - The remaining keys in the path to the desired field
+   * @param [formData] - The form data that is used to determine which oneOf option
+   * @returns - An object that contains the field and its required state. If no field can be found then
+   *            `{ field: undefined, isRequired: undefined }` is returned.
+   */
+  findFieldInSchema(schema, path, formData) {
+    return findFieldInSchema(
+      this.validator,
+      this.rootSchema,
+      schema,
+      path,
+      formData,
+      this.experimental_customMergeAllOf
+    );
+  }
+  /** Finds the oneOf option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` that
+   * matches the `formData[selectorField]` value. For the purposes of this function, `selectorField` is either
+   * `schema.discriminator.propertyName` or `fallbackField`.
+   *
+   * @param schema - The schema element in which to search for the selected oneOf option
+   * @param fallbackField - The field to use as a backup selector field if the schema does not have a required field
+   * @param xxx - Either `oneOf` or `anyOf`, defines which value is being sought
+   * @param [formData={}] - The form data that is used to determine which oneOf option
+   * @returns - The anyOf/oneOf option that matches the selector field in the schema or undefined if nothing is selected
+   */
+  findSelectedOptionInXxxOf(schema, fallbackField, xxx, formData) {
+    return findSelectedOptionInXxxOf(
+      this.validator,
+      this.rootSchema,
+      schema,
+      fallbackField,
+      xxx,
+      formData,
+      this.experimental_customMergeAllOf
+    );
+  }
   /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
    * computed to have defaults provided in the `schema`.
    *
@@ -2015,18 +2249,16 @@ var SchemaUtils = class {
   getFirstMatchingOption(formData, options, discriminatorField) {
     return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
   }
-  /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
-   * Deprecated, use `getFirstMatchingOption()` instead.
-   *
-   * @param formData - The current formData, if any, onto which to provide any missing defaults
-   * @param options - The list of options to find a matching options from
-   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-   *          determine which option is selected
-   * @returns - The index of the matched option or 0 if none is available
-   * @deprecated
-   */
-  getMatchingOption(formData, options, discriminatorField) {
-    return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
+  getFromSchema(schema, path, defaultValue) {
+    return getFromSchema(
+      this.validator,
+      this.rootSchema,
+      schema,
+      path,
+      // @ts-expect-error TS2769: No overload matches this call
+      defaultValue,
+      this.experimental_customMergeAllOf
+    );
   }
   /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
    *
@@ -2053,20 +2285,6 @@ var SchemaUtils = class {
   isSelect(schema) {
     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
-   * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
-   * then `validationData` is returned.
-   *
-   * @param validationData - The current `ValidationData` into which to merge the additional errors
-   * @param [additionalErrorSchema] - The additional set of errors
-   * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
-   * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
-   *        removed in the next major release.
-   */
-  mergeValidationData(validationData, additionalErrorSchema) {
-    return mergeValidationData(this.validator, validationData, additionalErrorSchema);
-  }
   /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
    * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
    * recursive resolution.
@@ -2283,7 +2501,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 import cloneDeep from "lodash/cloneDeep";
-import get11 from "lodash/get";
+import get15 from "lodash/get";
 import set3 from "lodash/set";
 import setWith from "lodash/setWith";
 var ErrorSchemaBuilder = class {
@@ -2312,7 +2530,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get11(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? get15(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2338,7 +2556,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get11(errorBlock, ERRORS_KEY);
+    let errorsList = get15(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -2474,6 +2692,10 @@ function getTemplate(name, registry, uiOptions = {}) {
   if (name === "ButtonTemplates") {
     return templates[name];
   }
+  if (Object.hasOwn(uiOptions, name) && typeof uiOptions[name] === "string" && Object.hasOwn(templates, uiOptions[name])) {
+    const key = uiOptions[name];
+    return templates[key];
+  }
   return (
     // Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent
     // To avoid that, we cast uiOptions to `any` before accessing the name field
@@ -2481,10 +2703,31 @@ function getTemplate(name, registry, uiOptions = {}) {
   );
 }
 
+// src/getTestIds.ts
+import { nanoid } from "nanoid";
+import get16 from "lodash/get";
+function getTestIds() {
+  if (typeof process === "undefined" || get16(process, "env.NODE_ENV") !== "test") {
+    return {};
+  }
+  const ids = /* @__PURE__ */ new Map();
+  return new Proxy(
+    {},
+    {
+      get(_obj, prop) {
+        if (!ids.has(prop)) {
+          ids.set(prop, nanoid());
+        }
+        return ids.get(prop);
+      }
+    }
+  );
+}
+
 // src/getWidget.tsx
 import { createElement } from "react";
 import ReactIs from "react-is";
-import get12 from "lodash/get";
+import get17 from "lodash/get";
 import set4 from "lodash/set";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
@@ -2540,7 +2783,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get12(AWidget, "MergedWidget");
+  let MergedWidget = get17(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2584,10 +2827,16 @@ function hashString(string) {
   }
   return hash.toString(16);
 }
-function hashForSchema(schema) {
+function sortedJSONStringify(object) {
   const allKeys = /* @__PURE__ */ new Set();
-  JSON.stringify(schema, (key, value) => (allKeys.add(key), value));
-  return hashString(JSON.stringify(schema, Array.from(allKeys).sort()));
+  JSON.stringify(object, (key, value) => (allKeys.add(key), value));
+  return JSON.stringify(object, Array.from(allKeys).sort());
+}
+function hashObject(object) {
+  return hashString(sortedJSONStringify(object));
+}
+function hashForSchema(schema) {
+  return hashObject(schema);
 }
 
 // src/hasWidget.ts
@@ -2632,6 +2881,9 @@ function ariaDescribedByIds(id, includeExamples = false) {
 function optionId(id, optionIndex) {
   return `${id}-${optionIndex}`;
 }
+function buttonId(id, btn) {
+  return idGenerator(id, btn);
+}
 
 // src/labelValue.ts
 function labelValue(label, hideLabel, fallback) {
@@ -2643,6 +2895,17 @@ function localToUTC(dateString) {
   return dateString ? new Date(dateString).toJSON() : void 0;
 }
 
+// src/lookupFromFormContext.ts
+import get18 from "lodash/get";
+import has6 from "lodash/has";
+function lookupFromFormContext(regOrFc, toLookup, fallback) {
+  const lookupPath = [LOOKUP_MAP_NAME];
+  if (has6(regOrFc, FORM_CONTEXT_NAME)) {
+    lookupPath.unshift(FORM_CONTEXT_NAME);
+  }
+  return get18(regOrFc, [...lookupPath, toLookup], fallback);
+}
+
 // src/orderProperties.ts
 function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
@@ -2819,7 +3082,7 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-import isEmpty3 from "lodash/isEmpty";
+import isEmpty4 from "lodash/isEmpty";
 function validationDataMerge(validationData, additionalErrorSchema) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -2827,7 +3090,7 @@ function validationDataMerge(validationData, additionalErrorSchema) {
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty3(oldErrorSchema)) {
+  if (!isEmpty4(oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
     errors = [...oldErrors].concat(errors);
   }
@@ -2868,7 +3131,7 @@ function withIdRefPrefix(schemaNode) {
 import keys from "lodash/keys";
 import pickBy from "lodash/pickBy";
 import isPlainObject4 from "lodash/isPlainObject";
-import get13 from "lodash/get";
+import get19 from "lodash/get";
 import difference from "lodash/difference";
 function getChangedFields(a, b) {
   const aIsPlainObject = isPlainObject4(a);
@@ -2881,7 +3144,7 @@ function getChangedFields(a, b) {
   } else if (!aIsPlainObject && bIsPlainObject) {
     return keys(b);
   } else {
-    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get13(b, key))));
+    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get19(b, key))));
     const diffFields = difference(keys(b), keys(a));
     return [...unequalFields, ...diffFields];
   }
@@ -2891,6 +3154,7 @@ function getChangedFields(a, b) {
 var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["ArrayItemTitle"] = "Item";
   TranslatableString2["MissingItems"] = "Missing items definition";
+  TranslatableString2["EmptyArray"] = "No items yet. Use the button below to add some.";
   TranslatableString2["YesLabel"] = "Yes";
   TranslatableString2["NoLabel"] = "No";
   TranslatableString2["CloseLabel"] = "Close";
@@ -2925,7 +3189,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 import forEach from "lodash/forEach";
 
 // src/parser/ParserValidator.ts
-import get14 from "lodash/get";
+import get20 from "lodash/get";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -2951,7 +3215,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get14(schema, ID_KEY, hash);
+    const key = get20(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -3050,20 +3314,24 @@ export {
   DEFAULT_KEY,
   DEFINITIONS_KEY,
   DEPENDENCIES_KEY,
+  DISCRIMINATOR_PATH,
   ENUM_KEY,
   ERRORS_KEY,
   ErrorSchemaBuilder,
+  FORM_CONTEXT_NAME,
   ID_KEY,
   IF_KEY,
   ITEMS_KEY,
   JUNK_OPTION_ID,
+  LOOKUP_MAP_NAME,
   NAME_KEY,
   ONE_OF_KEY,
+  PATTERN_PROPERTIES_KEY,
   PROPERTIES_KEY,
+  READONLY_KEY,
   REF_KEY,
   REQUIRED_KEY,
   RJSF_ADDITIONAL_PROPERTIES_FLAG,
-  RJSF_ADDITONAL_PROPERTIES_FLAG,
   ROOT_SCHEMA_PREFIX,
   SUBMIT_BTN_OPTIONS_KEY,
   TranslatableString,
@@ -3074,6 +3342,7 @@ export {
   allowAdditionalItems,
   ariaDescribedByIds,
   asNumber,
+  buttonId,
   canExpand,
   createErrorHandler,
   createSchemaUtils,
@@ -3089,7 +3358,9 @@ export {
   enumOptionsValueForIndex,
   errorId,
   examplesId,
+  findFieldInSchema,
   findSchemaDefinition,
+  findSelectedOptionInXxxOf,
   getChangedFields,
   getClosestMatchingOption,
   getDateElementProps,
@@ -3097,17 +3368,20 @@ export {
   getDiscriminatorFieldFromSchema,
   getDisplayLabel,
   getFirstMatchingOption,
+  getFromSchema,
   getInputProps,
-  getMatchingOption,
   getOptionMatchingSimpleDiscriminator,
   getSchemaType,
   getSubmitButtonOptions,
   getTemplate,
+  getTestIds,
   getUiOptions,
   getWidget,
   guessType,
   hasWidget,
   hashForSchema,
+  hashObject,
+  hashString,
   helpId,
   isConstant,
   isCustomWidget,
@@ -3118,10 +3392,10 @@ export {
   isSelect,
   labelValue,
   localToUTC,
+  lookupFromFormContext,
   mergeDefaultsWithFormData,
   mergeObjects,
   mergeSchemas,
-  mergeValidationData,
   optionId,
   optionsList,
   orderProperties,
@@ -3134,6 +3408,7 @@ export {
   schemaParser,
   schemaRequiresTrueValue,
   shouldRender,
+  sortedJSONStringify,
   titleId,
   toConstant,
   toDateString,