@rjsf/utils 6.0.0-beta.2 → 6.0.0-beta.20

package/dist/utils.esm.js

@@ -66,6 +66,8 @@ var REQUIRED_KEY = "required";
 var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
 var REF_KEY = "$ref";
 var SCHEMA_KEY = "$schema";
+var DEFAULT_ID_PREFIX = "root";
+var DEFAULT_ID_SEPARATOR = "_";
 var DISCRIMINATOR_PATH = ["discriminator", "propertyName"];
 var FORM_CONTEXT_NAME = "formContext";
 var LOOKUP_MAP_NAME = "layoutGridLookupMap";
@@ -75,10 +77,14 @@ var UI_FIELD_KEY = "ui:field";
 var UI_WIDGET_KEY = "ui:widget";
 var UI_OPTIONS_KEY = "ui:options";
 var UI_GLOBAL_OPTIONS_KEY = "ui:globalOptions";
+var JSON_SCHEMA_DRAFT_2019_09 = "https://json-schema.org/draft/2019-09/schema";
 var JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 
 // src/getUiOptions.ts
 function getUiOptions(uiSchema = {}, globalOptions = {}) {
+  if (!uiSchema) {
+    return { ...globalOptions };
+  }
   return Object.keys(uiSchema).filter((key) => key.indexOf("ui:") === 0).reduce(
     (options, key) => {
       const value = uiSchema[key];
@@ -148,15 +154,15 @@ function deepEquals(a, b) {
 }
 
 // src/schema/findFieldInSchema.ts
-import get7 from "lodash/get";
+import get8 from "lodash/get";
 import has3 from "lodash/has";
 
 // src/schema/findSelectedOptionInXxxOf.ts
-import get5 from "lodash/get";
+import get6 from "lodash/get";
 import isEqual from "lodash/isEqual";
 
 // src/schema/retrieveSchema.ts
-import get4 from "lodash/get";
+import get5 from "lodash/get";
 import set from "lodash/set";
 import times from "lodash/times";
 import transform from "lodash/transform";
@@ -171,12 +177,22 @@ import omit from "lodash/omit";
 import isObject2 from "lodash/isObject";
 import isEmpty from "lodash/isEmpty";
 import UriResolver from "fast-uri";
+import get from "lodash/get";
 function findEmbeddedSchemaRecursive(schema, ref) {
   if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY], ref)) {
     return schema;
   }
   for (const subSchema of Object.values(schema)) {
-    if (isObject2(subSchema)) {
+    if (Array.isArray(subSchema)) {
+      for (const item of subSchema) {
+        if (isObject2(item)) {
+          const result = findEmbeddedSchemaRecursive(item, ref);
+          if (result !== void 0) {
+            return result;
+          }
+        }
+      }
+    } else if (isObject2(subSchema)) {
       const result = findEmbeddedSchemaRecursive(subSchema, ref);
       if (result !== void 0) {
         return result;
@@ -185,12 +201,29 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   }
   return void 0;
 }
+function makeAllReferencesAbsolute(schema, baseURI) {
+  const currentURI = get(schema, ID_KEY, baseURI);
+  if (REF_KEY in schema) {
+    schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]) };
+  }
+  for (const [key, subSchema] of Object.entries(schema)) {
+    if (Array.isArray(subSchema)) {
+      schema = {
+        ...schema,
+        [key]: subSchema.map((item) => isObject2(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
+      };
+    } else if (isObject2(subSchema)) {
+      schema = { ...schema, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
+    }
+  }
+  return schema;
+}
 function splitKeyElementFromObject(key, object) {
   const value = object[key];
   const remaining = omit(object, [key]);
   return [remaining, value];
 }
-function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = ID_KEY in rootSchema ? rootSchema[ID_KEY] : void 0) {
+function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [], baseURI = get(rootSchema, [ID_KEY])) {
   const ref = $ref || "";
   let current = void 0;
   if (ref.startsWith("#")) {
@@ -230,23 +263,27 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
     const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref], baseURI);
     if (Object.keys(remaining).length > 0) {
-      return { ...remaining, ...subSchema };
+      if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2019_09 || rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+        return { [ALL_OF_KEY]: [remaining, subSchema] };
+      } else {
+        return { ...remaining, ...subSchema };
+      }
     }
     return subSchema;
   }
   return current;
 }
-function findSchemaDefinition($ref, rootSchema = {}, baseURI = ID_KEY in rootSchema ? rootSchema[ID_KEY] : void 0) {
+function findSchemaDefinition($ref, rootSchema = {}, baseURI = get(rootSchema, [ID_KEY])) {
   const recurseList = [];
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }
 
 // src/getDiscriminatorFieldFromSchema.ts
-import get from "lodash/get";
+import get2 from "lodash/get";
 import isString from "lodash/isString";
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = get(schema, DISCRIMINATOR_PATH);
+  const maybeString = get2(schema, DISCRIMINATOR_PATH);
   if (isString(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== void 0) {
@@ -320,21 +357,21 @@ function mergeSchemas(obj1, obj2) {
 }
 
 // src/schema/getFirstMatchingOption.ts
-import get3 from "lodash/get";
+import get4 from "lodash/get";
 import has from "lodash/has";
 import isNumber from "lodash/isNumber";
 
 // src/getOptionMatchingSimpleDiscriminator.ts
-import get2 from "lodash/get";
+import get3 from "lodash/get";
 function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) {
   if (formData && discriminatorField) {
-    const value = get2(formData, discriminatorField);
+    const value = get3(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], {});
+      const discriminator = get3(option, [PROPERTIES_KEY, discriminatorField], {});
       if (discriminator.type === "object" || discriminator.type === "array") {
         continue;
       }
@@ -361,8 +398,8 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
   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], {});
+      const value = get4(formData, discriminatorField);
+      const discriminator = get4(option, [PROPERTIES_KEY, discriminatorField], {});
       if (validator.isValid(discriminator, value, rootSchema)) {
         return i;
       }
@@ -502,7 +539,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
     rootSchema,
     expandAllBranches,
     recurseList,
-    formData
+    formData,
+    experimental_customMergeAllOf
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     return updatedSchemas;
@@ -514,7 +552,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       rootSchema,
       expandAllBranches,
       recurseList,
-      formData
+      formData,
+      experimental_customMergeAllOf
     );
     return resolvedSchemas.flatMap((s) => {
       return retrieveSchemaInternal(
@@ -617,9 +656,9 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       if (!isEmpty2(matchingProperties)) {
         schema.properties[key] = retrieveSchema(
           validator,
-          { allOf: Object.values(matchingProperties) },
+          { [ALL_OF_KEY]: Object.values(matchingProperties) },
           rootSchema,
-          formData,
+          get5(formData, [key]),
           experimental_customMergeAllOf
         );
         set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
@@ -632,7 +671,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(
             validator,
-            { $ref: get4(schema.additionalProperties, [REF_KEY]) },
+            { [REF_KEY]: get5(schema.additionalProperties, [REF_KEY]) },
             rootSchema,
             formData,
             experimental_customMergeAllOf
@@ -645,10 +684,10 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
             ...schema.additionalProperties
           };
         } else {
-          additionalProperties = { type: guessType(get4(formData, [key])) };
+          additionalProperties = { type: guessType(get5(formData, [key])) };
         }
       } else {
-        additionalProperties = { type: guessType(get4(formData, [key])) };
+        additionalProperties = { type: guessType(get5(formData, [key])) };
       }
       schema.properties[key] = additionalProperties;
       set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
@@ -727,7 +766,7 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
               validator,
               { allOf: [schema2.properties[key], ...Object.values(matchingProperties)] },
               rootSchema,
-              rawFormData,
+              get5(rawFormData, [key]),
               experimental_customMergeAllOf
             );
           }
@@ -799,7 +838,7 @@ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, r
 function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
   let schemas = [resolvedSchema];
   for (const dependencyKey in dependencies) {
-    if (!expandAllBranches && get4(formData, [dependencyKey]) === void 0) {
+    if (!expandAllBranches && get5(formData, [dependencyKey]) === void 0) {
       continue;
     }
     if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
@@ -930,11 +969,11 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
     const xxxOfs = schema[xxx].map(
       (xxxOf) => retrieveSchema(validator, xxxOf, rootSchema, formData, experimental_customMergeAllOf)
     );
-    const data = get5(formData, selectorField);
+    const data = get6(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])),
+          get6(xxx2, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get6(xxx2, [PROPERTIES_KEY, selectorField, CONST_KEY])),
           data
         );
       });
@@ -944,7 +983,7 @@ function findSelectedOptionInXxxOf(validator, rootSchema, schema, fallbackField,
 }
 
 // src/schema/getFromSchema.ts
-import get6 from "lodash/get";
+import get7 from "lodash/get";
 import has2 from "lodash/has";
 import isEmpty3 from "lodash/isEmpty";
 function getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf) {
@@ -958,7 +997,7 @@ function getFromSchemaInternal(validator, rootSchema, schema, path, experimental
   const pathList = Array.isArray(path) ? path : path.split(".");
   const [part, ...nestedPath] = pathList;
   if (part && has2(fieldSchema, part)) {
-    fieldSchema = get6(fieldSchema, part);
+    fieldSchema = get7(fieldSchema, part);
     return getFromSchemaInternal(
       validator,
       rootSchema,
@@ -1000,7 +1039,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
           parentField,
           fieldName,
           ONE_OF_KEY,
-          get7(formData, subPath),
+          get8(formData, subPath),
           experimental_customMergeAllOf
         );
       } else if (has3(parentField, ANY_OF_KEY)) {
@@ -1010,7 +1049,7 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
           parentField,
           fieldName,
           ANY_OF_KEY,
-          get7(formData, subPath),
+          get8(formData, subPath),
           experimental_customMergeAllOf
         );
       }
@@ -1064,11 +1103,11 @@ function findFieldInSchema(validator, rootSchema, schema, path, formData = {}, e
 }
 
 // src/schema/getDefaultFormState.ts
-import get11 from "lodash/get";
+import get12 from "lodash/get";
 import isEmpty4 from "lodash/isEmpty";
 
 // src/schema/getClosestMatchingOption.ts
-import get8 from "lodash/get";
+import get9 from "lodash/get";
 import has4 from "lodash/has";
 import isNumber2 from "lodash/isNumber";
 import isObject3 from "lodash/isObject";
@@ -1091,7 +1130,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
       totalScore += reduce(
         schema.properties,
         (score, value, key) => {
-          const formValue = get8(formData, key);
+          const formValue = get9(formData, key);
           if (typeof value === "boolean") {
             return score;
           }
@@ -1118,7 +1157,7 @@ function calculateIndexScore(validator, rootSchema, schema, formData, experiment
               validator,
               rootSchema,
               formValue,
-              get8(value, key2),
+              get9(value, key2),
               -1,
               discriminator,
               experimental_customMergeAllOf
@@ -1197,7 +1236,7 @@ function isFixedItems(schema) {
 }
 
 // src/mergeDefaultsWithFormData.ts
-import get9 from "lodash/get";
+import get10 from "lodash/get";
 import isNil from "lodash/isNil";
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false, defaultSupercedesUndefined = false, overrideFormDataWithDefaults = false) {
   if (Array.isArray(formData)) {
@@ -1224,11 +1263,22 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
   if (isObject(formData)) {
     const acc = Object.assign({}, defaults);
     return Object.keys(formData).reduce((acc2, key) => {
-      const keyValue = get9(formData, key);
+      const keyValue = get10(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
+      const keyDefault = get10(defaults, key) ?? {};
+      const defaultValueIsNestedObject = keyExistsInDefaults && Object.entries(keyDefault).some(([, v]) => isObject(v));
+      const keyDefaultIsObject = keyExistsInDefaults && isObject(get10(defaults, key));
+      const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
+      if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
+        acc2[key] = {
+          ...get10(defaults, key),
+          ...keyValue
+        };
+        return acc2;
+      }
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? get9(defaults, key) : {},
+        get10(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -1239,7 +1289,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       return acc2;
     }, acc);
   }
-  if (defaultSupercedesUndefined && (!isNil(defaults) && isNil(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
+  if (defaultSupercedesUndefined && (!(defaults === void 0) && isNil(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !isNil(formData)) {
     return defaults;
   }
   return formData;
@@ -1307,7 +1357,7 @@ function constIsAjvDataReference(schema) {
 }
 
 // src/optionsList.ts
-import get10 from "lodash/get";
+import get11 from "lodash/get";
 
 // src/toConstant.ts
 function toConstant(schema) {
@@ -1353,8 +1403,8 @@ function optionsList(schema, uiSchema) {
     let value;
     let label = title;
     if (selectorField) {
-      const innerSchema = get10(aSchema, [PROPERTIES_KEY, selectorField], {});
-      value = get10(innerSchema, DEFAULT_KEY, get10(innerSchema, CONST_KEY));
+      const innerSchema = get11(aSchema, [PROPERTIES_KEY, selectorField], {});
+      value = get11(innerSchema, DEFAULT_KEY, get11(innerSchema, CONST_KEY));
       label = label || innerSchema?.title || aSchema.title || String(value);
     } else {
       value = toConstant(aSchema);
@@ -1386,10 +1436,19 @@ function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, id
   }
   return {};
 }
+function computeDefaultBasedOnSchemaTypeAndDefaults(schema, computedDefault) {
+  const { default: schemaDefault, type } = schema;
+  const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && isEmpty4(computedDefault) && schemaDefault === null;
+  return shouldReturnNullAsDefault ? null : computedDefault;
+}
 function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false) {
   const { emptyObjectFields = "populateAllDefaults" } = experimental_defaultFormStateBehavior;
-  if (includeUndefinedValues || isConst) {
+  if (includeUndefinedValues === true || isConst) {
     obj[key] = computedDefault;
+  } else if (includeUndefinedValues === "excludeObjectChildren") {
+    if (!isObject(computedDefault) || !isEmpty4(computedDefault)) {
+      obj[key] = computedDefault;
+    }
   } else if (emptyObjectFields !== "skipDefaults") {
     const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
     if (isObject(computedDefault)) {
@@ -1423,13 +1482,13 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     required,
     shouldMergeDefaultsIntoFormData = false
   } = computeDefaultsProps;
-  const formData = isObject(rawFormData) ? rawFormData : {};
+  let formData = isObject(rawFormData) ? rawFormData : {};
   const schema = isObject(rawSchema) ? rawSchema : {};
   let defaults = parentDefaults;
   let schemaToCompute = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
-  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
+  if (schema[CONST_KEY] !== void 0 && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
     defaults = schema[CONST_KEY];
   } else if (isObject(defaults) && isObject(schema.default)) {
     defaults = mergeObjects(defaults, schema.default);
@@ -1444,6 +1503,9 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     if (schemaToCompute && !defaults) {
       defaults = schema.default;
     }
+    if (shouldMergeDefaultsIntoFormData && schemaToCompute && !isObject(rawFormData)) {
+      formData = rawFormData;
+    }
   } else if (DEPENDENCIES_KEY in schema) {
     const defaultFormData = {
       ...getDefaultBasedOnSchemaType(validator, schema, computeDefaultsProps, defaults),
@@ -1521,7 +1583,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
       experimental_customMergeAllOf,
       parentDefaults: defaults,
-      rawFormData: formData,
+      rawFormData: rawFormData ?? formData,
       required,
       shouldMergeDefaultsIntoFormData
     });
@@ -1584,7 +1646,7 @@ function getObjectDefaults(validator, rawSchema, {
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc, key) => {
-        const propertySchema = get11(retrievedSchema, [PROPERTIES_KEY, key], {});
+        const propertySchema = get12(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, {
@@ -1593,8 +1655,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get11(defaults, [key]),
-          rawFormData: get11(formData, [key]),
+          parentDefaults: get12(defaults, [key]),
+          rawFormData: get12(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData
         });
@@ -1630,8 +1692,8 @@ function getObjectDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get11(defaults, [key]),
-          rawFormData: get11(formData, [key]),
+          parentDefaults: get12(defaults, [key]),
+          rawFormData: get12(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData
         });
@@ -1645,7 +1707,7 @@ function getObjectDefaults(validator, rawSchema, {
         );
       });
     }
-    return objectDefaults;
+    return computeDefaultBasedOnSchemaTypeAndDefaults(rawSchema, objectDefaults);
   }
 }
 function getArrayDefaults(validator, rawSchema, {
@@ -1692,7 +1754,7 @@ function getArrayDefaults(validator, rawSchema, {
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           rawFormData: item,
-          parentDefaults: get11(defaults, [idx]),
+          parentDefaults: get12(defaults, [idx]),
           required,
           shouldMergeDefaultsIntoFormData
         });
@@ -1710,25 +1772,29 @@ function getArrayDefaults(validator, rawSchema, {
       return defaults ? defaults : void 0;
     }
   }
+  let arrayDefault;
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (!schema.minItems || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-    return defaults ? defaults : emptyDefault;
-  }
-  const defaultEntries = defaults || [];
-  const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
-  const fillerDefault = fillerSchema.default;
-  const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-    computeDefaults(validator, fillerSchema, {
-      parentDefaults: fillerDefault,
-      rootSchema,
-      _recurseList,
-      experimental_defaultFormStateBehavior,
-      experimental_customMergeAllOf,
-      required,
-      shouldMergeDefaultsIntoFormData
-    })
-  );
-  return defaultEntries.concat(fillerEntries);
+    arrayDefault = defaults ? defaults : emptyDefault;
+  } else {
+    const defaultEntries = defaults || [];
+    const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+    const fillerDefault = fillerSchema.default;
+    const fillerEntries = Array.from(
+      { length: schema.minItems - defaultsLength },
+      () => computeDefaults(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
+        required,
+        shouldMergeDefaultsIntoFormData
+      })
+    );
+    arrayDefault = defaultEntries.concat(fillerEntries);
+  }
+  return computeDefaultBasedOnSchemaTypeAndDefaults(rawSchema, arrayDefault);
 }
 function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
   switch (getSchemaType(rawSchema)) {
@@ -1754,6 +1820,12 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
     rawFormData: formData,
     shouldMergeDefaultsIntoFormData: true
   });
+  if (schema.type !== "object" && isObject(schema.default)) {
+    return {
+      ...defaults,
+      ...formData
+    };
+  }
   if (isObject(formData) || Array.isArray(formData)) {
     const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
     const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
@@ -1810,17 +1882,17 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   if (schemaType === "object") {
     displayLabel = false;
   }
-  if (schemaType === "boolean" && !uiSchema[UI_WIDGET_KEY]) {
+  if (schemaType === "boolean" && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
     displayLabel = false;
   }
-  if (uiSchema[UI_FIELD_KEY]) {
+  if (uiSchema && uiSchema[UI_FIELD_KEY]) {
     displayLabel = false;
   }
   return displayLabel;
 }
 
 // src/schema/sanitizeDataForNewSchema.ts
-import get12 from "lodash/get";
+import get13 from "lodash/get";
 import has5 from "lodash/has";
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
@@ -1828,19 +1900,19 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   if (has5(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if (has5(oldSchema, PROPERTIES_KEY)) {
-      const properties = get12(oldSchema, PROPERTIES_KEY, {});
+      const properties = get13(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if (has5(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys(get12(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys(get13(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = get12(data, key);
-      let oldKeyedSchema = get12(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get12(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = get13(data, key);
+      let oldKeyedSchema = get13(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get13(newSchema, [PROPERTIES_KEY, key], {});
       if (has5(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -1859,8 +1931,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = get12(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = get12(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = get13(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get13(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if (has5(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -1878,17 +1950,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = get12(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = get12(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = get13(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get13(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get12(newKeyedSchema, "readOnly") === true) {
+            } else if (get13(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get12(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = get12(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = get13(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get13(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -1900,9 +1972,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if (get12(oldSchema, "type") === "array" && get12(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = get12(oldSchema, "items");
-    let newSchemaItems = get12(newSchema, "items");
+  } else if (get13(oldSchema, "type") === "array" && get13(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get13(oldSchema, "items");
+    let newSchemaItems = get13(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if (has5(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -1922,10 +1994,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = get12(oldSchemaItems, "type");
-      const newSchemaType = get12(newSchemaItems, "type");
+      const oldSchemaType = get13(oldSchemaItems, "type");
+      const newSchemaType = get13(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get12(newSchema, "maxItems", -1);
+        const maxItems = get13(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -1952,78 +2024,6 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
-// src/schema/toIdSchema.ts
-import get13 from "lodash/get";
-function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
-  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,
-        get13(schema, ITEMS_KEY),
-        idPrefix,
-        idSeparator,
-        id,
-        rootSchema,
-        formData,
-        _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;
-}
-function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "root", idSeparator = "_", experimental_customMergeAllOf) {
-  return toIdSchemaInternal(
-    validator,
-    schema,
-    idPrefix,
-    idSeparator,
-    id,
-    rootSchema,
-    formData,
-    void 0,
-    experimental_customMergeAllOf
-  );
-}
-
 // src/schema/toPathSchema.ts
 import get14 from "lodash/get";
 import set2 from "lodash/set";
@@ -2139,6 +2139,7 @@ function toPathSchema(validator, schema, name = "", rootSchema, formData, experi
 }
 
 // src/createSchemaUtils.ts
+import get15 from "lodash/get";
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2148,11 +2149,22 @@ var SchemaUtils = class {
    * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
-    this.rootSchema = rootSchema;
+    if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, get15(rootSchema, ID_KEY, "#"));
+    } else {
+      this.rootSchema = rootSchema;
+    }
     this.validator = validator;
     this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
     this.experimental_customMergeAllOf = experimental_customMergeAllOf;
   }
+  /** Returns the `rootSchema` in the `SchemaUtilsType`
+   *
+   * @returns - The `rootSchema`
+   */
+  getRootSchema() {
+    return this.rootSchema;
+  }
   /** Returns the `ValidatorType` in the `SchemaUtilsType`
    *
    * @returns - The `ValidatorType`
@@ -2366,27 +2378,6 @@ var SchemaUtils = class {
       this.experimental_customMergeAllOf
     );
   }
-  /** Generates an `IdSchema` object for the `schema`, recursively
-   *
-   * @param schema - The schema for which the display label flag is desired
-   * @param [id] - The base id for the schema
-   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [idPrefix='root'] - The prefix to use for the id
-   * @param [idSeparator='_'] - The separator to use for the path segments in the id
-   * @returns - The `IdSchema` object for the `schema`
-   */
-  toIdSchema(schema, id, formData, idPrefix = "root", idSeparator = "_") {
-    return toIdSchema(
-      this.validator,
-      schema,
-      id,
-      this.rootSchema,
-      formData,
-      idPrefix,
-      idSeparator,
-      this.experimental_customMergeAllOf
-    );
-  }
   /** Generates an `PathSchema` object for the `schema`, recursively
    *
    * @param schema - The schema for which the display label flag is desired
@@ -2472,6 +2463,31 @@ function dateRangeOptions(start, stop) {
   return options;
 }
 
+// src/shallowEquals.ts
+function shallowEquals(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // src/replaceStringParameters.ts
 function replaceStringParameters(inputString, params) {
   let output = inputString;
@@ -2544,7 +2560,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 import cloneDeep from "lodash/cloneDeep";
-import get15 from "lodash/get";
+import get16 from "lodash/get";
 import set3 from "lodash/set";
 import setWith from "lodash/setWith";
 var ErrorSchemaBuilder = class {
@@ -2573,7 +2589,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get15(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? get16(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2599,7 +2615,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get15(errorBlock, ERRORS_KEY);
+    let errorsList = get16(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -2747,10 +2763,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-import { nanoid } from "nanoid";
-import get16 from "lodash/get";
+import get17 from "lodash/get";
+import uniqueId from "lodash/uniqueId";
 function getTestIds() {
-  if (typeof process === "undefined" || get16(process, "env.NODE_ENV") !== "test") {
+  if (typeof process === "undefined" || get17(process, "env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -2759,7 +2775,7 @@ function getTestIds() {
     {
       get(_obj, prop) {
         if (!ids.has(prop)) {
-          ids.set(prop, nanoid());
+          ids.set(prop, uniqueId("test-id-"));
         }
         return ids.get(prop);
       }
@@ -2770,7 +2786,7 @@ function getTestIds() {
 // src/getWidget.tsx
 import { createElement } from "react";
 import ReactIs from "react-is";
-import get17 from "lodash/get";
+import get18 from "lodash/get";
 import set4 from "lodash/set";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
@@ -2826,7 +2842,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get17(AWidget, "MergedWidget");
+  let MergedWidget = get18(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2842,7 +2858,7 @@ function getWidget(schema, widget, registeredWidgets = {}) {
     return mergeWidgetOptions(widget);
   }
   if (typeof widget !== "string") {
-    throw new Error(`Unsupported widget definition: ${typeof widget}`);
+    throw new Error(`Unsupported widget definition: ${typeof widget} in schema: ${JSON.stringify(schema)}`);
   }
   if (widget in registeredWidgets) {
     const registeredWidget = registeredWidgets[widget];
@@ -2850,14 +2866,14 @@ function getWidget(schema, widget, registeredWidgets = {}) {
   }
   if (typeof type === "string") {
     if (!(type in widgetMap)) {
-      throw new Error(`No widget for type '${type}'`);
+      throw new Error(`No widget for type '${type}' in schema: ${JSON.stringify(schema)}`);
     }
     if (widget in widgetMap[type]) {
       const registeredWidget = registeredWidgets[widgetMap[type][widget]];
       return getWidget(schema, registeredWidget, registeredWidgets);
     }
   }
-  throw new Error(`No widget '${widget}' for type '${type}'`);
+  throw new Error(`No widget '${widget}' for type '${type}' in schema: ${JSON.stringify(schema)}`);
 }
 
 // src/hashForSchema.ts
@@ -2939,14 +2955,14 @@ function localToUTC(dateString) {
 }
 
 // src/lookupFromFormContext.ts
-import get18 from "lodash/get";
+import get19 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);
+  return get19(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/orderProperties.ts
@@ -3027,7 +3043,14 @@ function schemaRequiresTrueValue(schema) {
 }
 
 // src/shouldRender.ts
-function shouldRender(component, nextProps, nextState) {
+function shouldRender(component, nextProps, nextState, updateStrategy = "customDeep") {
+  if (updateStrategy === "always") {
+    return true;
+  }
+  if (updateStrategy === "shallow") {
+    const { props: props2, state: state2 } = component;
+    return !shallowEquals(props2, nextProps) || !shallowEquals(state2, nextState);
+  }
   const { props, state } = component;
   return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
 }
@@ -3089,6 +3112,15 @@ function toErrorSchema(errors) {
   return builder.ErrorSchema;
 }
 
+// src/toFieldPathId.ts
+function toFieldPathId(fieldPath, globalFormOptions, parentPath) {
+  const basePath = Array.isArray(parentPath) ? parentPath : parentPath?.path;
+  const childPath = fieldPath === "" ? [] : [fieldPath];
+  const path = basePath ? basePath.concat(...childPath) : childPath;
+  const id = [globalFormOptions.idPrefix, ...path].join(globalFormOptions.idSeparator);
+  return { path, [ID_KEY]: id };
+}
+
 // src/unwrapErrorHandler.ts
 import isPlainObject3 from "lodash/isPlainObject";
 function unwrapErrorHandler(errorHandler) {
@@ -3174,7 +3206,7 @@ function withIdRefPrefix(schemaNode) {
 import keys from "lodash/keys";
 import pickBy from "lodash/pickBy";
 import isPlainObject4 from "lodash/isPlainObject";
-import get19 from "lodash/get";
+import get20 from "lodash/get";
 import difference from "lodash/difference";
 function getChangedFields(a, b) {
   const aIsPlainObject = isPlainObject4(a);
@@ -3187,7 +3219,7 @@ function getChangedFields(a, b) {
   } else if (!aIsPlainObject && bIsPlainObject) {
     return keys(b);
   } else {
-    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get19(b, key))));
+    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get20(b, key))));
     const diffFields = difference(keys(b), keys(a));
     return [...unequalFields, ...diffFields];
   }
@@ -3232,7 +3264,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 import forEach from "lodash/forEach";
 
 // src/parser/ParserValidator.ts
-import get20 from "lodash/get";
+import get21 from "lodash/get";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -3258,7 +3290,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get20(schema, ID_KEY, hash);
+    const key = get21(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -3354,6 +3386,8 @@ export {
   ALL_OF_KEY,
   ANY_OF_KEY,
   CONST_KEY,
+  DEFAULT_ID_PREFIX,
+  DEFAULT_ID_SEPARATOR,
   DEFAULT_KEY,
   DEFINITIONS_KEY,
   DEPENDENCIES_KEY,
@@ -3365,6 +3399,7 @@ export {
   ID_KEY,
   IF_KEY,
   ITEMS_KEY,
+  JSON_SCHEMA_DRAFT_2019_09,
   JSON_SCHEMA_DRAFT_2020_12,
   JUNK_OPTION_ID,
   LOOKUP_MAP_NAME,
@@ -3452,6 +3487,7 @@ export {
   sanitizeDataForNewSchema,
   schemaParser,
   schemaRequiresTrueValue,
+  shallowEquals,
   shouldRender,
   sortedJSONStringify,
   titleId,
@@ -3459,7 +3495,7 @@ export {
   toDateString,
   toErrorList,
   toErrorSchema,
-  toIdSchema,
+  toFieldPathId,
   toPathSchema,
   unwrapErrorHandler,
   utcToLocal,