Merge remote-tracking branch 'origin/main' into nested-object-conditional-defaul

Author: abdalla-rko

CHANGELOG.md

@@ -21,6 +21,7 @@ should change the heading of the (upcoming) version to include a major version b
 ## @rjsf/utils
 
 - Fixed issue with default value not being prefilled when object with if/then is nested inside another object, fixing [#4222](https://github.com/rjsf-team/react-jsonschema-form/issues/4222)
+- Fixed issue with schema array with nested dependent fixed-length, fixing [#3754](https://github.com/rjsf-team/react-jsonschema-form/issues/3754)
 
 
 # 6.1.2

packages/utils/src/schema/getDefaultFormState.ts

@@ -619,12 +619,14 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   if (Array.isArray(defaults)) {
     defaults = defaults.map((item, idx) => {
       const schemaItem: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Fallback, idx);
+      const itemFormData = Array.isArray(rawFormData) ? rawFormData[idx] : undefined;
       return computeDefaults<T, S, F>(validator, schemaItem, {
         rootSchema,
         _recurseList,
         experimental_defaultFormStateBehavior,
         experimental_customMergeAllOf,
         parentDefaults: item,
+        rawFormData: itemFormData,
         required,
         shouldMergeDefaultsIntoFormData,
         initialDefaultsGenerated,

packages/utils/test/schema/getDefaultFormStateTest.ts

@@ -1947,6 +1947,107 @@ export default function getDefaultFormStateTest(testValidator: TestValidatorType
         });
       });
 
+      describe('array with nested dependent fixed-length array schema', () => {
+        const schema: RJSFSchema = {
+          items: [
+            {
+              dependencies: {
+                checkbox: {
+                  if: {
+                    properties: {
+                      checkbox: {
+                        const: true,
+                      },
+                    },
+                  },
+                  then: {
+                    properties: {
+                      inner_array: {
+                        items: [
+                          {
+                            title: 'Fixed Item',
+                            type: 'string',
+                          },
+                        ],
+                        title: 'Inner Fixed-Length Array',
+                        type: 'array',
+                      },
+                    },
+                  },
+                },
+              },
+              properties: {
+                checkbox: {
+                  title: 'Dependency Checkbox',
+                  type: 'boolean',
+                },
+              },
+              title: 'Outer Item',
+              type: 'object',
+            },
+          ],
+          title: 'Outer Fixed Length Array',
+          type: 'array',
+        };
+        const formData = [{ checkbox: true }];
+        const includeUndefinedValues = 'excludeObjectChildren';
+        const expected = [
+          {
+            checkbox: true,
+            inner_array: [undefined],
+          },
+        ];
+
+        test('getDefaultFormState', () => {
+          expect(getDefaultFormState(testValidator, schema, formData, undefined, includeUndefinedValues)).toEqual(
+            expected,
+          );
+        });
+
+        test('computeDefaults', () => {
+          expect(
+            computeDefaults(testValidator, schema, {
+              rawFormData: formData,
+              includeUndefinedValues,
+              shouldMergeDefaultsIntoFormData: true,
+            }),
+          ).toEqual(expected);
+        });
+
+        test('getDefaultBasedOnSchemaType', () => {
+          expect(
+            getDefaultBasedOnSchemaType(
+              testValidator,
+              schema,
+              {
+                includeUndefinedValues,
+              },
+              [
+                {
+                  checkbox: true,
+                },
+              ],
+            ),
+          ).toEqual(expected);
+        });
+
+        test('getArrayDefaults', () => {
+          expect(
+            getArrayDefaults(
+              testValidator,
+              schema,
+              {
+                includeUndefinedValues,
+              },
+              [
+                {
+                  checkbox: true,
+                },
+              ],
+            ),
+          ).toEqual(expected);
+        });
+      });
       describe('an invalid array schema', () => {
         const schema: RJSFSchema = {
           type: 'array',