fix: apply nested const defaults in conditional schemas (#5132)

Co-authored-by: Heath C <51679588+heath-freenome@users.noreply.github.com>

Author: morgan-coded

CHANGELOG.md

@@ -36,6 +36,7 @@ should change the heading of the (upcoming) version to include a major version b
 - Added a warning when a `select` widget schema default is not present in the enum options, fixing [#4494](https://github.com/rjsf-team/react-jsonschema-form/issues/4494)
 - Fixed `SchemaField` so that a schema with a primitive or array `type` alongside a non-select `oneOf`/`anyOf` no longer renders a spurious duplicate input above the option selector, fixing [#5119](https://github.com/rjsf-team/react-jsonschema-form/issues/5119)
 - Fixed `MultiSchemaField` to propagate the parent schema's `type` to option sub-schemas that don't define their own, so the correct widget (e.g. `StringField`) renders for the selected option instead of `FallbackField`, fixing [#5119](https://github.com/rjsf-team/react-jsonschema-form/issues/5119)
+- Fixed nested `constAsDefaults` values being skipped in matching conditional `allOf` schemas, fixing [#4963](https://github.com/rjsf-team/react-jsonschema-form/issues/4963)
 
 ## @rjsf/daisyui
 

packages/utils/src/schema/getDefaultFormState.ts

@@ -460,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;
@@ -825,9 +850,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.

packages/utils/test/schema/getDefaultFormStateTest.ts

@@ -5327,6 +5327,89 @@ export default function getDefaultFormStateTest(testValidator: TestValidatorType
             }),
           ).toEqual({ animalInfo: { animal: 'Cat', food: 'meat' } });
         });
+
+        it('should apply conditional const defaults consistently for root and nested allOf schemas', () => {
+          const experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior = {
+            allOf: 'populateDefaults',
+            constAsDefaults: 'always',
+          };
+          const conditionalSchema = {
+            type: 'object',
+            properties: {
+              animal: {
+                enum: ['Cat', 'Fish'],
+              },
+              food: {
+                type: 'string',
+                enum: ['meat', 'grass', 'fish'],
+              },
+            },
+            allOf: [
+              {
+                if: {
+                  properties: {
+                    animal: {
+                      const: 'Cat',
+                    },
+                  },
+                },
+                then: {
+                  properties: {
+                    food: {
+                      const: 'fish',
+                    },
+                  },
+                  required: ['food'],
+                },
+              },
+              {
+                required: ['animal'],
+              },
+            ],
+          } satisfies RJSFSchema;
+          const formData = {
+            animal: 'Cat',
+            food: 'meat',
+          };
+
+          expect(
+            getDefaultFormState(
+              testValidator,
+              conditionalSchema,
+              formData,
+              conditionalSchema,
+              undefined,
+              experimental_defaultFormStateBehavior,
+            ),
+          ).toEqual({
+            animal: 'Cat',
+            food: 'fish',
+          });
+
+          const nestedSchema: RJSFSchema = {
+            type: 'object',
+            properties: {
+              nested: conditionalSchema,
+            },
+            required: ['nested'],
+          };
+
+          expect(
+            getDefaultFormState(
+              testValidator,
+              nestedSchema,
+              { nested: formData },
+              nestedSchema,
+              undefined,
+              experimental_defaultFormStateBehavior,
+            ),
+          ).toEqual({
+            nested: {
+              animal: 'Cat',
+              food: 'fish',
+            },
+          });
+        });
       });
 
       describe('default form state behaviour: allOf = "skipDefaults"', () => {