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

package/src/findSchemaDefinition.ts

@@ -1,11 +1,19 @@
 import jsonpointer from 'jsonpointer';
 import omit from 'lodash/omit';
 
-import { ID_KEY, JSON_SCHEMA_DRAFT_2020_12, REF_KEY, SCHEMA_KEY } from './constants';
+import {
+  ALL_OF_KEY,
+  ID_KEY,
+  JSON_SCHEMA_DRAFT_2019_09,
+  JSON_SCHEMA_DRAFT_2020_12,
+  REF_KEY,
+  SCHEMA_KEY,
+} from './constants';
 import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
 import isObject from 'lodash/isObject';
 import isEmpty from 'lodash/isEmpty';
 import UriResolver from 'fast-uri';
+import get from 'lodash/get';
 
 /** Looks for the `$id` pointed by `ref` in the schema definitions embedded in
  * a JSON Schema bundle
@@ -19,7 +27,16 @@ function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(sc
     return schema;
   }
   for (const subSchema of Object.values(schema)) {
-    if (isObject(subSchema)) {
+    if (Array.isArray(subSchema)) {
+      for (const item of subSchema) {
+        if (isObject(item)) {
+          const result = findEmbeddedSchemaRecursive<S>(item as S, ref);
+          if (result !== undefined) {
+            return result as S;
+          }
+        }
+      }
+    } else if (isObject(subSchema)) {
       const result = findEmbeddedSchemaRecursive<S>(subSchema as S, ref);
       if (result !== undefined) {
         return result as S;
@@ -29,6 +46,31 @@ function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(sc
   return undefined;
 }
 
+/** Parses a JSONSchema and makes all references absolute with respect to
+ * the `baseURI` argument
+ * @param schema - The schema to be processed
+ * @param baseURI - The base URI to be used for resolving relative references
+ */
+export function makeAllReferencesAbsolute<S extends StrictRJSFSchema = RJSFSchema>(schema: S, baseURI: string): S {
+  const currentURI = get(schema, ID_KEY, baseURI);
+  // Make all other references absolute
+  if (REF_KEY in schema) {
+    schema = { ...schema, [REF_KEY]: UriResolver.resolve(currentURI, schema[REF_KEY]!) };
+  }
+  // Look for references in nested subschemas
+  for (const [key, subSchema] of Object.entries(schema)) {
+    if (Array.isArray(subSchema)) {
+      schema = {
+        ...schema,
+        [key]: subSchema.map((item) => (isObject(item) ? makeAllReferencesAbsolute(item as S, currentURI) : item)),
+      };
+    } else if (isObject(subSchema)) {
+      schema = { ...schema, [key]: makeAllReferencesAbsolute(subSchema as S, currentURI) };
+    }
+  }
+  return schema;
+}
+
 /** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
  * location, the `object` minus the `key: value` and in the second location the `value`.
  *
@@ -51,7 +93,7 @@ export function splitKeyElementFromObject(key: string, object: GenericObjectType
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
  * @param recurseList - List of $refs already resolved to prevent recursion
- * @param baseURI - The base URI to be used for resolving relative references
+ * @param [baseURI=rootSchema['$id']] - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
@@ -59,7 +101,7 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
   $ref?: string,
   rootSchema: S = {} as S,
   recurseList: string[] = [],
-  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
+  baseURI: string | undefined = get(rootSchema, [ID_KEY]),
 ): S {
   const ref = $ref || '';
   let current: S | undefined = undefined;
@@ -102,7 +144,14 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
     const subSchema = findSchemaDefinitionRecursive<S>(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] } as S;
+      } else {
+        return { ...remaining, ...subSchema };
+      }
     }
     return subSchema;
   }
@@ -123,7 +172,7 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
 export default function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
   rootSchema: S = {} as S,
-  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
+  baseURI: string | undefined = get(rootSchema, [ID_KEY]),
 ): S {
   const recurseList: string[] = [];
   return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);

package/src/getTestIds.ts

@@ -1,5 +1,5 @@
-import { nanoid } from 'nanoid';
 import get from 'lodash/get';
+import uniqueId from 'lodash/uniqueId';
 
 import { TestIdShape } from './types';
 
@@ -31,7 +31,7 @@ export default function getTestIds(): TestIdShape {
     {
       get(_obj, prop) {
         if (!ids.has(prop)) {
-          ids.set(prop, nanoid());
+          ids.set(prop, uniqueId('test-id-'));
         }
         return ids.get(prop);
       },

package/src/getUiOptions.ts

@@ -13,6 +13,10 @@ export default function getUiOptions<T = any, S extends StrictRJSFSchema = RJSFS
   uiSchema: UiSchema<T, S, F> = {},
   globalOptions: GlobalUISchemaOptions = {},
 ): UIOptionsType<T, S, F> {
+  // Handle null or undefined uiSchema
+  if (!uiSchema) {
+    return { ...globalOptions };
+  }
   return Object.keys(uiSchema)
     .filter((key) => key.indexOf('ui:') === 0)
     .reduce(

package/src/getWidget.tsx

@@ -110,7 +110,7 @@ export default function getWidget<T = any, S extends StrictRJSFSchema = RJSFSche
   }
 
   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) {
@@ -120,7 +120,7 @@ export default function getWidget<T = any, S extends StrictRJSFSchema = RJSFSche
 
   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]) {
@@ -129,5 +129,5 @@ export default function getWidget<T = any, S extends StrictRJSFSchema = RJSFSche
     }
   }
 
-  throw new Error(`No widget '${widget}' for type '${type}'`);
+  throw new Error(`No widget '${widget}' for type '${type}' in schema: ${JSON.stringify(schema)}`);
 }

package/src/idGenerators.ts

@@ -1,73 +1,73 @@
 import isString from 'lodash/isString';
 
-import { IdSchema } from './types';
+import { FieldPathId } from './types';
 import { ID_KEY } from './constants';
 
 /** Generates a consistent `id` pattern for a given `id` and a `suffix`
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @param suffix - The suffix to append to the id
  */
-function idGenerator<T = any>(id: IdSchema<T> | string, suffix: string) {
+function idGenerator(id: FieldPathId | string, suffix: string) {
   const theId = isString(id) ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
 /** Return a consistent `id` for the field description element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @returns - The consistent id for the field description element from the given `id`
  */
-export function descriptionId<T = any>(id: IdSchema<T> | string) {
-  return idGenerator<T>(id, 'description');
+export function descriptionId(id: FieldPathId | string) {
+  return idGenerator(id, 'description');
 }
 
 /** Return a consistent `id` for the field error element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @returns - The consistent id for the field error element from the given `id`
  */
-export function errorId<T = any>(id: IdSchema<T> | string) {
-  return idGenerator<T>(id, 'error');
+export function errorId(id: FieldPathId | string) {
+  return idGenerator(id, 'error');
 }
 
 /** Return a consistent `id` for the field examples element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @returns - The consistent id for the field examples element from the given `id`
  */
-export function examplesId<T = any>(id: IdSchema<T> | string) {
-  return idGenerator<T>(id, 'examples');
+export function examplesId(id: FieldPathId | string) {
+  return idGenerator(id, 'examples');
 }
 
 /** Return a consistent `id` for the field help element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @returns - The consistent id for the field help element from the given `id`
  */
-export function helpId<T = any>(id: IdSchema<T> | string) {
-  return idGenerator<T>(id, 'help');
+export function helpId(id: FieldPathId | string) {
+  return idGenerator(id, 'help');
 }
 
 /** Return a consistent `id` for the field title element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @returns - The consistent id for the field title element from the given `id`
  */
-export function titleId<T = any>(id: IdSchema<T> | string) {
-  return idGenerator<T>(id, 'title');
+export function titleId(id: FieldPathId | string) {
+  return idGenerator(id, 'title');
 }
 
 /** Return a list of element ids that contain additional information about the field that can be used to as the aria
  * description of the field. This is correctly omitting `titleId` which would be "labeling" rather than "describing" the
  * element.
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list
  * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute
  */
-export function ariaDescribedByIds<T = any>(id: IdSchema<T> | string, includeExamples = false) {
-  const examples = includeExamples ? ` ${examplesId<T>(id)}` : '';
-  return `${errorId<T>(id)} ${descriptionId<T>(id)} ${helpId<T>(id)}${examples}`;
+export function ariaDescribedByIds(id: FieldPathId | string, includeExamples = false) {
+  const examples = includeExamples ? ` ${examplesId(id)}` : '';
+  return `${errorId(id)} ${descriptionId(id)} ${helpId(id)}${examples}`;
 }
 
 /** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget
@@ -82,10 +82,10 @@ export function optionId(id: string, optionIndex: number) {
 
 /** Return a consistent `id` for the `btn` button element
  *
- * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param id - Either simple string id or an FieldPathId from which to extract it
  * @param btn - The button type for which to generate the id
  * @returns - The consistent id for the button from the given `id` and `btn` type
  */
-export function buttonId<T = any>(id: IdSchema<T> | string, btn: 'add' | 'copy' | 'moveDown' | 'moveUp' | 'remove') {
-  return idGenerator<T>(id, btn);
+export function buttonId(id: FieldPathId | string, btn: 'add' | 'copy' | 'moveDown' | 'moveUp' | 'remove') {
+  return idGenerator(id, btn);
 }

package/src/index.ts

@@ -6,6 +6,7 @@ import createSchemaUtils from './createSchemaUtils';
 import dataURItoBlob from './dataURItoBlob';
 import dateRangeOptions from './dateRangeOptions';
 import deepEquals from './deepEquals';
+import shallowEquals from './shallowEquals';
 import englishStringTranslator from './englishStringTranslator';
 import enumOptionsDeselectValue from './enumOptionsDeselectValue';
 import enumOptionsIndexForValue from './enumOptionsIndexForValue';
@@ -58,6 +59,7 @@ import toConstant from './toConstant';
 import toDateString from './toDateString';
 import toErrorList from './toErrorList';
 import toErrorSchema from './toErrorSchema';
+import toFieldPathId from './toFieldPathId';
 import unwrapErrorHandler from './unwrapErrorHandler';
 import utcToLocal from './utcToLocal';
 import validationDataMerge from './validationDataMerge';
@@ -130,6 +132,7 @@ export {
   rangeSpec,
   replaceStringParameters,
   schemaRequiresTrueValue,
+  shallowEquals,
   shouldRender,
   sortedJSONStringify,
   titleId,
@@ -137,8 +140,11 @@ export {
   toDateString,
   toErrorList,
   toErrorSchema,
+  toFieldPathId,
   unwrapErrorHandler,
   utcToLocal,
   validationDataMerge,
   withIdRefPrefix,
 };
+
+export type { ComponentUpdateStrategy } from './shouldRender';

package/src/mergeDefaultsWithFormData.ts

@@ -67,8 +67,22 @@ export default function mergeDefaultsWithFormData<T = any>(
       const keyValue = get(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in (defaults as GenericObjectType);
       const keyExistsInFormData = key in (formData as GenericObjectType);
+      const keyDefault = get(defaults, key) ?? {};
+      const defaultValueIsNestedObject = keyExistsInDefaults && Object.entries(keyDefault).some(([, v]) => isObject(v));
+
+      const keyDefaultIsObject = keyExistsInDefaults && isObject(get(defaults, key));
+      const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
+
+      if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
+        acc[key as keyof T] = {
+          ...get(defaults, key),
+          ...keyValue,
+        };
+        return acc;
+      }
+
       acc[key as keyof T] = mergeDefaultsWithFormData<T>(
-        defaults ? get(defaults, key) : {},
+        get(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -88,7 +102,7 @@ export default function mergeDefaultsWithFormData<T = any>(
    */
   if (
     (defaultSupercedesUndefined &&
-      ((!isNil(defaults) && isNil(formData)) || (typeof formData === 'number' && isNaN(formData)))) ||
+      ((!(defaults === undefined) && isNil(formData)) || (typeof formData === 'number' && isNaN(formData)))) ||
     (overrideFormDataWithDefaults && !isNil(formData))
   ) {
     return defaults;

package/src/schema/findFieldInSchema.ts

@@ -22,7 +22,7 @@ export const NOT_FOUND_SCHEMA = { title: '!@#$_UNKNOWN_$#@!' };
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
  * @param rootSchema - The root schema that will be forwarded to all the APIs
- // * @param schema - The node within the JSON schema in which to search
+ * @param schema - The node within the JSON schema in which to search
  * @param path - The keys in the path to the desired field
  * @param [formData={}] - The form data that is used to determine which anyOf/oneOf option to descend
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas

package/src/schema/getDefaultFormState.ts

@@ -84,6 +84,24 @@ export function getInnerSchemaForArrayItem<S extends StrictRJSFSchema = RJSFSche
   return {} as S;
 }
 
+/** Checks if the given `schema` contains the `null` type along with another type AND if the `default` contained within
+ * the schema is `null` AND the `computedDefault` is empty. If all of those conditions are true, then the `schema`'s
+ * default should be `null` rather than `computedDefault`.
+ *
+ * @param schema - The schema to inspect
+ * @param computedDefault - The computed default for the schema
+ * @returns - Flag indicating whether a null should be returned instead of the computedDefault
+ */
+export function computeDefaultBasedOnSchemaTypeAndDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S,
+  computedDefault: T,
+) {
+  const { default: schemaDefault, type } = schema;
+  const shouldReturnNullAsDefault =
+    Array.isArray(type) && type.includes('null') && isEmpty(computedDefault) && schemaDefault === null;
+  return shouldReturnNullAsDefault ? (null as T) : computedDefault;
+}
+
 /** Either add `computedDefault` at `key` into `obj` or not add it based on its value, the value of
  * `includeUndefinedValues`, the value of `emptyObjectFields` and if its parent field is required. Generally undefined
  * `computedDefault` values are added only when `includeUndefinedValues` is either true/"excludeObjectChildren". If `
@@ -115,10 +133,18 @@ function maybeAddDefaultToObject<T = any>(
   isConst = false,
 ) {
   const { emptyObjectFields = 'populateAllDefaults' } = experimental_defaultFormStateBehavior;
-  if (includeUndefinedValues || isConst) {
-    // If includeUndefinedValues
+
+  if (includeUndefinedValues === true || isConst) {
+    // If includeUndefinedValues is explicitly true
     // Or if the schema has a const property defined, then we should always return the computedDefault since it's coming from the const.
     obj[key] = computedDefault;
+  } else if (includeUndefinedValues === 'excludeObjectChildren') {
+    // Fix for Issue #4709: When in 'excludeObjectChildren' mode, don't set primitive fields to empty objects
+    // Only add the computed default if it's not an empty object placeholder for a primitive field
+    if (!isObject(computedDefault) || !isEmpty(computedDefault)) {
+      obj[key] = computedDefault;
+    }
+    // If computedDefault is an empty object {}, don't add it - let the field stay undefined
   } else if (emptyObjectFields !== 'skipDefaults') {
     // If isParentRequired is undefined, then we are at the root level of the schema so defer to the requiredness of
     // the field key itself in the `requiredField` list
@@ -204,7 +230,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     required,
     shouldMergeDefaultsIntoFormData = false,
   } = computeDefaultsProps;
-  const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
+  let formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
   const schema: S = isObject(rawSchema) ? rawSchema : ({} as S);
   // Compute the defaults recursively: give highest priority to deepest nodes.
   let defaults: T | T[] | undefined = parentDefaults;
@@ -212,9 +238,8 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
   let schemaToCompute: S | null = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
-
   if (
-    schema[CONST_KEY] &&
+    schema[CONST_KEY] !== undefined &&
     experimental_defaultFormStateBehavior?.constAsDefaults !== 'never' &&
     !constIsAjvDataReference(schema)
   ) {
@@ -240,6 +265,13 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     if (schemaToCompute && !defaults) {
       defaults = schema.default as T | undefined;
     }
+
+    // If shouldMergeDefaultsIntoFormData is true
+    // And the schemaToCompute is set and the rawFormData is not an object
+    // Then set the formData to the rawFormData
+    if (shouldMergeDefaultsIntoFormData && schemaToCompute && !isObject(rawFormData)) {
+      formData = rawFormData as T;
+    }
   } else if (DEPENDENCIES_KEY in schema) {
     // Get the default if set from properties to ensure the dependencies conditions are resolved based on it
     const defaultFormData: T = {
@@ -328,7 +360,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
       experimental_customMergeAllOf,
       parentDefaults: defaults as T | undefined,
-      rawFormData: formData as T,
+      rawFormData: (rawFormData ?? formData) as T,
       required,
       shouldMergeDefaultsIntoFormData,
     });
@@ -432,7 +464,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     required,
     shouldMergeDefaultsIntoFormData,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
+  defaults?: T | T[],
 ): T {
   {
     const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
@@ -467,6 +499,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
         });
+
         maybeAddDefaultToObject<T>(
           acc,
           key,
@@ -477,6 +510,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           experimental_defaultFormStateBehavior,
           hasConst,
         );
+
         return acc;
       },
       {},
@@ -523,7 +557,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
         );
       });
     }
-    return objectDefaults;
+    return computeDefaultBasedOnSchemaTypeAndDefaults<T, S>(rawSchema, objectDefaults);
   }
 }
 
@@ -547,8 +581,8 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     required,
     shouldMergeDefaultsIntoFormData,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
-): T | T[] | undefined {
+  defaults?: T[],
+): T[] | undefined {
   const schema: S = rawSchema;
 
   const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
@@ -560,7 +594,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   const computeSkipPopulate = arrayMinItemsStateBehavior?.computeSkipPopulate ?? (() => false);
   const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === 'skipEmptyDefaults';
 
-  const emptyDefault = isSkipEmptyDefaults ? undefined : [];
+  const emptyDefault: T[] | undefined = isSkipEmptyDefaults ? undefined : [];
 
   // Inject defaults into existing array defaults
   if (Array.isArray(defaults)) {
@@ -582,7 +616,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   if (Array.isArray(rawFormData)) {
     const schemaItem: S = getInnerSchemaForArrayItem<S>(schema);
     if (neverPopulate) {
-      defaults = rawFormData;
+      defaults = rawFormData as typeof defaults;
     } else {
       const itemDefaults = rawFormData.map((item: T, idx: number) => {
         return computeDefaults<T, S, F>(validator, schemaItem, {
@@ -619,6 +653,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     }
   }
 
+  let arrayDefault: T[] | undefined;
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (
     !schema.minItems ||
@@ -626,27 +661,29 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
     schema.minItems <= defaultsLength
   ) {
-    return defaults ? defaults : emptyDefault;
+    arrayDefault = defaults ? defaults : emptyDefault;
+  } else {
+    const defaultEntries: T[] = (defaults || []) as T[];
+    const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
+    const fillerDefault = fillerSchema.default;
+
+    // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
+    const fillerEntries: T[] = Array.from({ length: schema.minItems - defaultsLength }, () =>
+      computeDefaults<any, S, F>(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
+        required,
+        shouldMergeDefaultsIntoFormData,
+      }),
+    ) as T[];
+    // then fill up the rest with either the item default or empty, up to minItems
+    arrayDefault = defaultEntries.concat(fillerEntries);
   }
 
-  const defaultEntries: T[] = (defaults || []) as T[];
-  const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
-  const fillerDefault = fillerSchema.default;
-
-  // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-  const fillerEntries: T[] = new Array(schema.minItems - defaultsLength).fill(
-    computeDefaults<any, S, F>(validator, fillerSchema, {
-      parentDefaults: fillerDefault,
-      rootSchema,
-      _recurseList,
-      experimental_defaultFormStateBehavior,
-      experimental_customMergeAllOf,
-      required,
-      shouldMergeDefaultsIntoFormData,
-    }),
-  ) as T[];
-  // then fill up the rest with either the item default or empty, up to minItems
-  return defaultEntries.concat(fillerEntries);
+  return computeDefaultBasedOnSchemaTypeAndDefaults<T[] | undefined, S>(rawSchema, arrayDefault);
 }
 
 /** Computes the default value based on the schema type.
@@ -673,7 +710,7 @@ export function getDefaultBasedOnSchemaType<
       return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
     }
     case 'array': {
-      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults as T[]);
     }
   }
 }
@@ -722,6 +759,13 @@ export default function getDefaultFormState<
     shouldMergeDefaultsIntoFormData: true,
   });
 
+  if (schema.type !== 'object' && isObject(schema.default)) {
+    return {
+      ...defaults,
+      ...formData,
+    } as T;
+  }
+
   // If the formData is an object or an array, add additional properties from formData and override formData with
   // defaults since the defaults are already merged with formData.
   if (isObject(formData) || Array.isArray(formData)) {

package/src/schema/getDisplayLabel.ts

@@ -52,10 +52,10 @@ export default function getDisplayLabel<
   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;

package/src/schema/index.ts

@@ -10,7 +10,6 @@ import isMultiSelect from './isMultiSelect';
 import isSelect from './isSelect';
 import retrieveSchema from './retrieveSchema';
 import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
-import toIdSchema from './toIdSchema';
 import toPathSchema from './toPathSchema';
 
 export {
@@ -26,6 +25,5 @@ export {
   isSelect,
   retrieveSchema,
   sanitizeDataForNewSchema,
-  toIdSchema,
   toPathSchema,
 };

package/src/schema/retrieveSchema.ts

@@ -241,6 +241,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
     expandAllBranches,
     recurseList,
     formData,
+    experimental_customMergeAllOf,
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     // return the updatedSchemas array if it has either multiple schemas within it
@@ -255,6 +256,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       expandAllBranches,
       recurseList,
       formData,
+      experimental_customMergeAllOf,
     );
     return resolvedSchemas.flatMap((s) => {
       return retrieveSchemaInternal<T, S, F>(
@@ -334,7 +336,7 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param schema - The schema for which resolving all references is desired
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @param recurseList - List of $refs already resolved to prevent recursion
- * @param baseURI - The base URI to be used for resolving relative references
+ * @param [baseURI] - The base URI to be used for resolving relative references
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
@@ -430,9 +432,9 @@ export function stubExistingAdditionalProperties<
       if (!isEmpty(matchingProperties)) {
         schema.properties[key] = retrieveSchema<T, S, F>(
           validator,
-          { allOf: Object.values(matchingProperties) } as S,
+          { [ALL_OF_KEY]: Object.values(matchingProperties) } as S,
           rootSchema,
-          formData as T,
+          get(formData, [key]) as T,
           experimental_customMergeAllOf,
         );
         set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
@@ -445,7 +447,7 @@ export function stubExistingAdditionalProperties<
         if (REF_KEY in schema.additionalProperties!) {
           additionalProperties = retrieveSchema<T, S, F>(
             validator,
-            { $ref: get(schema.additionalProperties, [REF_KEY]) } as S,
+            { [REF_KEY]: get(schema.additionalProperties, [REF_KEY]) } as S,
             rootSchema,
             formData as T,
             experimental_customMergeAllOf,
@@ -578,7 +580,7 @@ export function retrieveSchemaInternal<
               validator,
               { allOf: [schema.properties[key], ...Object.values(matchingProperties)] } as S,
               rootSchema,
-              rawFormData as T,
+              get(rawFormData, [key]) as T,
               experimental_customMergeAllOf,
             );
           }