@rjsf/utils 6.6.2 → 6.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rjsf/utils",
-  "version": "6.6.2",
+  "version": "6.7.0",
   "main": "dist/index.js",
   "module": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -42,20 +42,6 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "compileReplacer": "tsc -p tsconfig.replacer.json && move-file lodashReplacer.js lodashReplacer.cjs",
-    "build:ts": "npm run compileReplacer && rimraf ./lib && tsc -b tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.cjs --sourcemap --packages=external --format=cjs",
-    "build:esm": "esbuild ./src/index.ts --bundle --outfile=dist/utils.esm.js --sourcemap --packages=external --format=esm",
-    "build:umd": "rollup dist/utils.esm.js --format=umd --file=dist/utils.umd.js --name=@rjsf/utils",
-    "build": "npm run build:ts && npm run build:cjs && npm run build:esm && npm run build:umd",
-    "cs-check": "oxfmt --check \"{src,test}/**/*.{ts,tsx}\"",
-    "cs-format": "oxfmt \"{src,test}/**/*.{ts,tsx}\"",
-    "lint": "oxlint src test",
-    "precommit": "lint-staged",
-    "test": "vitest run",
-    "test:debug": "node --inspect-brk ../../node_modules/.bin/vitest --pool=forks"
-  },
   "lint-staged": {
     "{src,test}/**/*.{ts,tsx}": [
       "oxlint --fix",
@@ -68,7 +54,7 @@
   "dependencies": {
     "@x0k/json-schema-merge": "^1.0.3",
     "fast-equals": "^6.0.0",
-    "fast-uri": "^3.1.2",
+    "fast-uri": "^4.0.0",
     "jsonpointer": "^5.0.1",
     "lodash": "^4.18.1",
     "lodash-es": "^4.18.1",
@@ -77,7 +63,7 @@
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
     "@types/react-is": "^18.3.1",
-    "deep-freeze-es6": "^4.0.1"
+    "deep-freeze-es6": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -96,5 +82,19 @@
     "type": "git",
     "url": "git+https://github.com/rjsf-team/react-jsonschema-form.git"
   },
-  "license": "Apache-2.0"
-}
+  "license": "Apache-2.0",
+  "scripts": {
+    "compileReplacer": "tsc -p tsconfig.replacer.json && move-file lodashReplacer.js lodashReplacer.cjs",
+    "build:ts": "pnpm run compileReplacer && rimraf ./lib && tsc -b tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "build:cjs": "esbuild ./src/index.ts --bundle --outfile=dist/index.cjs --sourcemap --packages=external --format=cjs",
+    "build:esm": "esbuild ./src/index.ts --bundle --outfile=dist/utils.esm.js --sourcemap --packages=external --format=esm",
+    "build:umd": "rollup dist/utils.esm.js --format=umd --file=dist/utils.umd.js --name=@rjsf/utils",
+    "build": "pnpm run build:ts && pnpm run build:cjs && pnpm run build:esm && pnpm run build:umd",
+    "cs-check": "oxfmt --check \"{src,test}/**/*.{ts,tsx}\"",
+    "cs-format": "oxfmt \"{src,test}/**/*.{ts,tsx}\"",
+    "lint": "oxlint src test",
+    "precommit": "lint-staged",
+    "test": "vitest run",
+    "test:debug": "node --inspect-brk ../../node_modules/.bin/vitest --pool=forks"
+  }
+}

package/src/SelectedOptionDescription.tsx

@@ -0,0 +1,48 @@
+import enumOptionsIsSelected from './enumOptionsIsSelected';
+import getTemplate from './getTemplate';
+import getUiOptions from './getUiOptions';
+import { descriptionId } from './idGenerators';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, WidgetProps } from './types';
+
+export type SelectedOptionDescriptionProps<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+> = Pick<WidgetProps<T, S, F>, 'id' | 'multiple' | 'options' | 'registry' | 'uiSchema' | 'value' | 'hideLabel'>;
+
+/** Renders the description associated with the selected oneOf or anyOf option in a single-select widget. */
+export default function SelectedOptionDescription<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>({ hideLabel, id, multiple, options, registry, uiSchema, value }: SelectedOptionDescriptionProps<T, S, F>) {
+  if (multiple || hideLabel) {
+    return null;
+  }
+
+  const { label = true } = getUiOptions<T, S, F>(uiSchema, registry.globalUiOptions);
+  if (!label) {
+    return null;
+  }
+
+  const option = options.enumOptions?.find(({ value: enumValue }) => enumOptionsIsSelected(enumValue, value));
+  const description = option?.schema?.description;
+  if (!description) {
+    return null;
+  }
+
+  const DescriptionFieldTemplate = getTemplate<'DescriptionFieldTemplate', T, S, F>(
+    'DescriptionFieldTemplate',
+    registry,
+    options,
+  );
+  return (
+    <DescriptionFieldTemplate
+      id={descriptionId(id)}
+      description={description}
+      schema={option.schema!}
+      uiSchema={uiSchema}
+      registry={registry}
+    />
+  );
+}

package/src/constants.ts

@@ -1,9 +1,10 @@
 /** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
- * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
- * `RJSF_ADDITIONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
- * utility.
+ * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG`,
+ * `RJSF_REF_KEY`, and `RJSF_REF_CYCLE_KEY` Symbols that are added to a schema under certain conditions by the
+ * `retrieveSchema()` utility. Using Symbols keeps these internal markers invisible to JSON serialisation and
+ * JSON Schema validators (AJV, ATA, etc.), which only enumerate string-keyed properties.
  */
-export const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
+export const ADDITIONAL_PROPERTY_FLAG = Symbol('__additional_property');
 export const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
 export const ALL_OF_KEY = 'allOf';
 export const ANY_OF_KEY = 'anyOf';
@@ -25,7 +26,8 @@ export const READONLY_KEY = 'readonly';
 export const REQUIRED_KEY = 'required';
 export const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
 export const REF_KEY = '$ref';
-export const RJSF_REF_KEY = '__rjsf_ref';
+export const RJSF_REF_KEY = Symbol('__rjsf_ref');
+export const RJSF_REF_CYCLE_KEY = Symbol('__rjsf_ref_cycle');
 export const SCHEMA_KEY = '$schema';
 export const DEFAULT_ID_PREFIX = 'root';
 export const DEFAULT_ID_SEPARATOR = '_';
@@ -40,8 +42,9 @@ export const FORM_CONTEXT_NAME = 'formContext';
 /** The name of the `layoutGridLookupMap` attribute in the form context
  */
 export const LOOKUP_MAP_NAME = 'layoutGridLookupMap';
-export const RJSF_ADDITIONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
-export const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
+export const RJSF_PREFIX_KEY = '__rjsf';
+export const RJSF_ADDITIONAL_PROPERTIES_FLAG = `${RJSF_PREFIX_KEY}_additionalProperties`;
+export const ROOT_SCHEMA_PREFIX = `${RJSF_PREFIX_KEY}_rootSchema`;
 export const UI_FIELD_KEY = 'ui:field';
 export const UI_WIDGET_KEY = 'ui:widget';
 export const UI_OPTIONS_KEY = 'ui:options';

package/src/createSchemaUtils.ts

@@ -63,7 +63,7 @@ class SchemaUtils<
     experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior,
     experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
   ) {
-    if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+    if (rootSchema?.[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
       this.rootSchema = makeAllReferencesAbsolute(rootSchema, get(rootSchema, ID_KEY, '#'));
     } else {
       this.rootSchema = rootSchema;

package/src/enums.ts

@@ -27,6 +27,8 @@ export enum TranslatableString {
   AddItemButton = 'Add Item',
   /** Copy button title, used by IconButton */
   CopyButton = 'Copy',
+  /** Expand cycle button title */
+  ExpandButton = 'Expand Cycle',
   /** Move down button title, used by IconButton */
   MoveDownButton = 'Move down',
   /** Move up button title, used by IconButton */
@@ -70,6 +72,8 @@ export enum TranslatableString {
   KeyLabel = '%1 Key',
   /** Deprecated label, where %1 will be replaced by the label as provided by SchemaField */
   DeprecatedLabel = '%1 (deprecated)',
+  /** Cyclic schema message */
+  CycleDetected = 'Circular reference ($ref cycle) detected for field "%1". You may choose to expand to the next cycle break',
   // Strings with replaceable parameters AND/OR that support markdown and html
   /** Invalid object field configuration as provided by the ObjectField.
    * NOTE: Use markdown notation rather than html tags.

package/src/getSubmitButtonOptions.ts

@@ -23,7 +23,7 @@ export default function getSubmitButtonOptions<
   F extends FormContextType = any,
 >(uiSchema: UiSchema<T, S, F> = {}): UISchemaSubmitButtonOptions {
   const uiOptions = getUiOptions<T, S, F>(uiSchema);
-  if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
+  if (uiOptions?.[SUBMIT_BTN_OPTIONS_KEY]) {
     const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
     return { ...DEFAULT_OPTIONS, ...options };
   }

package/src/getWidget.tsx

@@ -75,7 +75,7 @@ function mergeWidgetOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, F
   // cache return value as property of widget for proper react reconciliation
   if (!MergedWidget) {
     // oxlint-disable-next-line typescript/no-deprecated
-    const defaultOptions = (AWidget.defaultProps && AWidget.defaultProps.options) || {};
+    const defaultOptions = AWidget.defaultProps?.options || {};
     MergedWidget = ({ options, ...props }) => <AWidget options={{ ...defaultOptions, ...options }} {...props} />;
     set(AWidget, 'MergedWidget', MergedWidget);
   }

package/src/hashForSchema.ts

@@ -47,10 +47,12 @@ export function hashObject(object: unknown): string {
 
 /** Stringifies the schema and returns the hash of the resulting string. Sorts schema fields
  * in consistent order before stringify to prevent different hash ids for the same schema.
+ * Symbol-keyed properties (RJSF_REF_KEY, RJSF_REF_CYCLE_KEY, ADDITIONAL_PROPERTY_FLAG) are
+ * automatically excluded by JSON.stringify, so no special filtering is needed.
  *
  * @param schema - The schema for which the hash is desired
  * @returns - The string obtained from the hash of the stringified schema
  */
 export default function hashForSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
-  return hashObject(schema);
+  return hashString(sortedJSONStringify(schema));
 }

package/src/index.ts

@@ -52,6 +52,7 @@ import isObject from './isObject';
 import isRootSchema from './isRootSchema';
 import labelValue from './labelValue';
 import localToUTC from './localToUTC';
+import logUnsupportedDefaultForEnum from './logUnsupportedDefaultForEnum';
 import lookupFromFormContext from './lookupFromFormContext';
 import mergeDefaultsWithFormData from './mergeDefaultsWithFormData';
 import mergeObjects from './mergeObjects';
@@ -66,6 +67,8 @@ import removeOptionalEmptyObjects from './removeOptionalEmptyObjects';
 import replaceStringParameters from './replaceStringParameters';
 import resolveUiSchema from './resolveUiSchema';
 import schemaRequiresTrueValue from './schemaRequiresTrueValue';
+import SelectedOptionDescription from './SelectedOptionDescription';
+import type { SelectedOptionDescriptionProps } from './SelectedOptionDescription';
 import shallowEquals from './shallowEquals';
 import type { ComponentUpdateStrategy } from './shouldRender';
 import shouldRender from './shouldRender';
@@ -98,6 +101,7 @@ export type {
   DateElementProp,
   DateElementProps,
   FileInfoType,
+  SelectedOptionDescriptionProps,
   UseAltDateWidgetResult,
   UseFileWidgetPropsResult,
 };
@@ -154,6 +158,7 @@ export {
   isRootSchema,
   labelValue,
   localToUTC,
+  logUnsupportedDefaultForEnum,
   lookupFromFormContext,
   mergeDefaultsWithFormData,
   mergeObjects,
@@ -170,6 +175,7 @@ export {
   replaceStringParameters,
   resolveUiSchema,
   schemaRequiresTrueValue,
+  SelectedOptionDescription,
   shallowEquals,
   shouldRender,
   shouldRenderOptionalField,

package/src/isFixedItems.ts

@@ -1,12 +1,12 @@
 import isObject from './isObject';
 import type { RJSFSchema, StrictRJSFSchema } from './types';
 
-/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
- * that only contains objects.
+/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is an array that only
+ * contains objects.
  *
  * @param schema - The schema in which to check for fixed items
  * @returns - True if there are fixed items in the schema, false otherwise
  */
 export default function isFixedItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
-  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
+  return Array.isArray(schema.items) && schema.items.every((item) => isObject(item));
 }

package/src/isRootSchema.ts

@@ -1,6 +1,4 @@
-import omit from 'lodash/omit';
-
-import { REF_KEY, RJSF_REF_KEY } from './constants';
+import { REF_KEY } from './constants';
 import deepEquals from './deepEquals';
 import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types';
 
@@ -25,7 +23,7 @@ export default function isRootSchema<T = any, S extends StrictRJSFSchema = RJSFS
   }
   if (REF_KEY in rootSchema) {
     const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-    return deepEquals(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
+    return deepEquals(schemaToCompare, resolvedSchema);
   }
   return false;
 }

package/src/logUnsupportedDefaultForEnum.ts

@@ -0,0 +1,28 @@
+import enumOptionsIndexForValue from './enumOptionsIndexForValue';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Logs a warning when a single-select enum widget has a schema default that is not one of its enum options.
+ *
+ * @param id - The field id used in the warning message
+ * @param schema - The schema whose default value is checked
+ * @param enumOptions - The enum options available to the widget
+ * @param multiple - Whether the widget allows multiple selections
+ */
+export default function logUnsupportedDefaultForEnum<S extends StrictRJSFSchema = RJSFSchema>(
+  id: string,
+  schema: S,
+  enumOptions?: EnumOptionsType<S>[],
+  multiple = false,
+) {
+  if (
+    !multiple &&
+    Array.isArray(enumOptions) &&
+    schema.default !== undefined &&
+    enumOptionsIndexForValue<S>(schema.default, enumOptions, multiple) === undefined
+  ) {
+    // oxlint-disable-next-line no-console
+    console.error(
+      `The schema default value "${schema.default}" is not one of the values in the enum options for "${id}"`,
+    );
+  }
+}

package/src/mergeSchemas.ts

@@ -3,7 +3,7 @@ import union from 'lodash/union';
 import { REQUIRED_KEY } from './constants';
 import getSchemaType from './getSchemaType';
 import isObject from './isObject';
-import type { GenericObjectType } from './types';
+import type { GenericObjectType, GenericSymbolObjectType } from './types';
 
 /** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
  * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
@@ -15,7 +15,7 @@ import type { GenericObjectType } from './types';
  */
 export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjectType) {
   const acc = { ...obj1 }; // Prevent mutation of source object.
-  return Object.keys(obj2).reduce((accumulator, key) => {
+  const result = Object.keys(obj2).reduce((accumulator, key) => {
     const left = obj1 ? obj1[key] : {},
       right = obj2[key];
     if (obj1 && key in obj1 && isObject(right)) {
@@ -35,4 +35,11 @@ export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjec
     }
     return accumulator;
   }, acc);
+  // Copy own Symbol-keyed properties from obj2 (Object.keys skips them).
+  for (const sym of Object.getOwnPropertySymbols(obj2)) {
+    // To avoid issues with symbols, we cast them to GenericSymbolObjectType. If we make the mergeSchema function take
+    // in GenericSymbolObjectType rather than GenericObjectType, it causes a bunch of type errors downstream
+    (result as GenericSymbolObjectType)[sym] = (obj2 as GenericSymbolObjectType)[sym];
+  }
+  return result;
 }

package/src/optionsList.ts

@@ -79,26 +79,24 @@ export default function optionsList<T = any, S extends StrictRJSFSchema = RJSFSc
     const { optionsSchemaSelector = selectorField } = getUiOptions<T, S, F>(uiSchema);
     selectorField = optionsSchemaSelector;
   }
-  return (
-    altSchemas &&
-    altSchemas.map((aSchemaDef, index) => {
-      const { title } = getUiOptions<T, S, F>(altUiSchemas?.[index]);
-      const aSchema = aSchemaDef as S;
-      let value: EnumOptionsType<S>['value'];
-      let label = title;
-      if (selectorField) {
-        const innerSchema: S = get(aSchema, [PROPERTIES_KEY, selectorField], {}) as S;
-        value = get(innerSchema, DEFAULT_KEY, get(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,
-        value,
-      };
-    })
-  );
+  return altSchemas?.map((aSchemaDef, index) => {
+    const { title } = getUiOptions<T, S, F>(altUiSchemas?.[index]);
+    const aSchema = aSchemaDef as S;
+    let value: EnumOptionsType<S>['value'];
+    let label = title;
+    if (selectorField) {
+      const innerSchema: S = get(aSchema, [PROPERTIES_KEY, selectorField], {}) as S;
+      value = get(innerSchema, DEFAULT_KEY, get(innerSchema, CONST_KEY));
+      // Use nullish coalescing so that an explicitly empty string title is preserved
+      label = label ?? innerSchema?.title ?? aSchema.title ?? String(value);
+    } else {
+      value = toConstant(aSchema);
+      label = label ?? aSchema.title ?? String(value);
+    }
+    return {
+      schema: aSchema,
+      label,
+      value,
+    };
+  });
 }

package/src/resolveUiSchema.ts

@@ -3,7 +3,15 @@ import isEmpty from 'lodash/isEmpty';
 import { ANY_OF_KEY, ONE_OF_KEY, REF_KEY, RJSF_REF_KEY } from './constants';
 import findSchemaDefinition from './findSchemaDefinition';
 import mergeObjects from './mergeObjects';
-import type { FormContextType, GenericObjectType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import type {
+  FormContextType,
+  GenericObjectType,
+  Registry,
+  RJSFMarkedSchema,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+} from './types';
 
 /** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
  *
@@ -26,7 +34,7 @@ export default function resolveUiSchema<
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
 >(schema: S, localUiSchema: UiSchema<T, S, F> | undefined, registry: Registry<T, S, F>): UiSchema<T, S, F> {
-  const ref = ((schema as GenericObjectType)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
+  const ref = ((schema as RJSFMarkedSchema)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
   const definitions = registry.uiSchemaDefinitions;
   const definitionUiSchema = ref && definitions ? definitions[ref] : undefined;
 
@@ -47,7 +55,7 @@ export default function resolveUiSchema<
   // can read dropdown option titles at the parent level.
   if (definitions) {
     let resolvedSchema: S = schema;
-    if (ref && schema[REF_KEY] && !(schema as GenericObjectType)[RJSF_REF_KEY]) {
+    if (ref && schema[REF_KEY] && !(schema as RJSFMarkedSchema)[RJSF_REF_KEY]) {
       try {
         resolvedSchema = findSchemaDefinition<S>(ref, registry.rootSchema);
       } catch (e) {
@@ -66,7 +74,7 @@ export default function resolveUiSchema<
         let hasExpanded = false;
         for (let i = 0; i < schemaOptions.length; i++) {
           const option = schemaOptions[i] as GenericObjectType | undefined;
-          const optionRef = (option?.[RJSF_REF_KEY] ?? option?.[REF_KEY]) as string | undefined;
+          const optionRef = ((option as RJSFMarkedSchema)?.[RJSF_REF_KEY] ?? option?.[REF_KEY]) as string | undefined;
           if (optionRef && optionRef in definitions) {
             const optionUiSchema = (uiSchemaArray[i] || {}) as GenericObjectType;
             uiSchemaArray[i] = mergeObjects(definitions[optionRef] as GenericObjectType, optionUiSchema) as UiSchema<

package/src/schema/getDefaultFormState.ts

@@ -232,16 +232,18 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     rootSchema = {} as S,
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData = false,
     initialDefaultsGenerated,
   } = computeDefaultsProps;
   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.
+  // Compute the defaults recursively: give highest priority to deepest nodes unless nestedDefaultsPrecedence is ancestorWins.
   let defaults: T | T[] | undefined = parentDefaults;
+  const preferParentDefaults =
+    defaults && experimental_defaultFormStateBehavior?.nestedDefaultsPrecedence === 'ancestorWins';
   // If we get a new schema, then we need to recompute defaults again for the new schema found.
   let schemaToCompute: S | null = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
@@ -259,12 +261,25 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     !schema[ONE_OF_KEY] &&
     !schema[REF_KEY]
   ) {
-    // For object defaults, only override parent defaults that are defined in
-    // schema.default. Skip this for anyOf/oneOf/$ref schemas - they need special handling.
-    defaults = mergeObjects(defaults, schema.default as GenericObjectType) as T;
-  } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
-    // If the schema has a default value, then we should use it as the default.
-    // And if the schema does not have anyOf or oneOf, this is done because we need to merge the defaults with the formData.
+    // For object defaults, merge defaults by precedence setting.
+    // Skip this for anyOf/oneOf/$ref schemas - they need special handling.
+    if (preferParentDefaults) {
+      // Use schema.default as the base and only override values that are defined in parent defaults.
+      defaults = mergeObjects(schema.default as GenericObjectType, defaults) as T;
+    } else {
+      // Only override parent defaults that are defined in schema.default.
+      defaults = mergeObjects(defaults, schema.default as GenericObjectType) as T;
+    }
+  } else if (
+    DEFAULT_KEY in schema &&
+    !preferParentDefaults &&
+    !schema[ANY_OF_KEY] &&
+    !schema[ONE_OF_KEY] &&
+    !schema[REF_KEY]
+  ) {
+    // If the schema has a default value and parentDefaults does not have precedence
+    // And if the schema does not have anyOf or oneOf (since we need to merge the defaults with the formData)
+    // Then we should use it as the default.
     defaults = schema.default as unknown as T;
   } else if (REF_KEY in schema) {
     const refName = schema[REF_KEY];
@@ -305,7 +320,9 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       experimental_customMergeAllOf,
     );
     [schemaToCompute] = resolvedSchema; // pick the first element from resolve dependencies
-  } else if (isFixedItems(schema)) {
+  } else if (isFixedItems(schema) && !preferParentDefaults) {
+    // If the schema contains fixed items and parentDefaults does not have precedence
+    // Then construct defaults from defaults of array items.
     defaults = (schema.items! as S[]).map((itemSchema: S, idx: number) =>
       computeDefaults<T, S>(validator, itemSchema, {
         rootSchema,
@@ -443,19 +460,44 @@ export function ensureFormDataMatchingSchema<
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): T | T[] | undefined {
+  const shouldRetrieveAllOf =
+    experimental_defaultFormStateBehavior?.allOf === 'populateDefaults' && ALL_OF_KEY in schema;
+  const schemaToMatch = shouldRetrieveAllOf
+    ? retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf)
+    : schema;
   const isSelectField =
-    !isConstant<S>(schema) && isSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf);
+    !isConstant<S>(schemaToMatch) &&
+    isSelect<T, S, F>(validator, schemaToMatch, rootSchema, experimental_customMergeAllOf);
   let validFormData: T | T[] | undefined = formData;
   if (isSelectField) {
-    const getOptionsList = optionsList<T, S, F>(schema);
+    const getOptionsList = optionsList<T, S, F>(schemaToMatch);
     const isValid = getOptionsList?.some((option) => deepEquals(option.value, formData));
     validFormData = isValid ? formData : undefined;
   }
 
   // Override the formData with the const if the constAsDefaults is set to always
-  const constTakesPrecedence = schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === 'always';
+  const constTakesPrecedence =
+    schemaToMatch[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults === 'always';
   if (constTakesPrecedence) {
-    validFormData = schema.const as T;
+    validFormData = schemaToMatch.const as T;
+  } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
+    validFormData = Object.keys(schemaToMatch.properties).reduce(
+      (acc: GenericObjectType, key: string) => {
+        const propertySchema: S = get(schemaToMatch, [PROPERTIES_KEY, key], {}) as S;
+        if (key in acc && (shouldRetrieveAllOf || (isObject(propertySchema) && ALL_OF_KEY in propertySchema))) {
+          acc[key] = ensureFormDataMatchingSchema<T, S, F>(
+            validator,
+            propertySchema,
+            rootSchema,
+            get(acc, key),
+            experimental_defaultFormStateBehavior,
+            experimental_customMergeAllOf,
+          );
+        }
+        return acc;
+      },
+      { ...(validFormData as GenericObjectType) },
+    ) as T;
   }
 
   return validFormData;
@@ -477,8 +519,8 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     rootSchema = {} as S,
     includeUndefinedValues = false,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     shouldMergeDefaultsIntoFormData,
     initialDefaultsGenerated,
@@ -605,8 +647,8 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     rawFormData,
     rootSchema = {} as S,
     _recurseList = [],
-    experimental_defaultFormStateBehavior = undefined,
-    experimental_customMergeAllOf = undefined,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
     required,
     requiredAsRoot = false,
     shouldMergeDefaultsIntoFormData,
@@ -674,7 +716,16 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     }
   }
 
+  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+
   if (neverPopulate) {
+    if (shouldMergeDefaultsIntoFormData) {
+      if (schema.minItems && schema.minItems > defaultsLength) {
+        const fillerEntries = Array.from({ length: schema.minItems - defaultsLength }, () => null) as T[];
+        return (defaults ?? []).concat(fillerEntries);
+      }
+      return defaults;
+    }
     return defaults ?? emptyDefault;
   }
   if (ignoreMinItemsFlagSet && !required) {
@@ -684,7 +735,6 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   }
 
   let arrayDefault: T[] | undefined;
-  const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (
     !schema.minItems ||
     isMultiSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf) ||
@@ -733,8 +783,8 @@ export function getDefaultBasedOnSchemaType<
   validator: ValidatorType<T, S, F>,
   rawSchema: S,
   computeDefaultsProps: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
-): T | T[] | void {
+  defaults?: T | T[],
+): T | T[] | undefined {
   switch (getSchemaType<S>(rawSchema)) {
     // We need to recurse for object schema inner default values.
     case 'object': {
@@ -808,9 +858,17 @@ export default function getDefaultFormState<
   if (isObject(formData) || Array.isArray(formData)) {
     const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
     const defaultSupercedesUndefined = mergeDefaultsIntoFormData === 'useDefaultIfFormDataUndefined';
+    const matchingFormData = ensureFormDataMatchingSchema<T, S, F>(
+      validator,
+      schema,
+      rootSchema ?? schema,
+      formData,
+      experimental_defaultFormStateBehavior,
+      experimental_customMergeAllOf,
+    );
     const result = mergeDefaultsWithFormData<T | T[]>(
       defaults,
-      formData,
+      matchingFormData,
       true, // set to true to add any additional default array entries.
       defaultSupercedesUndefined,
       true, // set to true to override formData with defaults if they exist.