Fix object reference sharing in arrays with discriminated unions and minItems

Fixes #4756

When arrays with minItems > 0 were populated for discriminated unions (oneOf with discriminator),
the Array.fill() method created shared object references instead of independent instances.
This caused form field changes to affect multiple array items simultaneously.

Solution:
- Replace Array.fill() with Array.from() in getArrayDefaults function
- Array.from() creates independent object instances for each array item
- Maintains existing behavior while fixing the reference sharing bug

Added comprehensive test coverage for:
- Basic object independence in arrays
- Nested object scenarios
- Exact reproduction case from issue #4756
- Integration with discriminated union schemas

Author: The-Zona-Zoo

CHANGELOG.md

@@ -38,6 +38,7 @@ should change the heading of the (upcoming) version to include a major version b
 - BREAKING CHANGE: Removed `formContext` from the following interfaces because it is available on `registry`:
   - `ErrorListProps`, `FieldProps`, `FieldTemplateProps`, `ArrayFieldTemplateProps` and `WidgetProps`
 - Update `mergeDefaultsWithFormData` to properly handle overriding `undefined` formData with a `null` default value, fixing [#4734](https://github.com/rjsf-team/react-jsonschema-form/issues/4734)
+- Fixed object reference sharing in arrays with minItems when using oneOf schemas, fixing [#4756](https://github.com/rjsf-team/react-jsonschema-form/issues/4756)
 
 ## Dev / docs / playground
 
@@ -234,7 +235,7 @@ should change the heading of the (upcoming) version to include a major version b
 
 ## @rjsf/mui
 
-- Fixed build process to remove the `tsc-alias` replacer that was adding `/index.js` onto the `@mui/Xxxx` imports since MUI 7 has proper ESM support 
+- Fixed build process to remove the `tsc-alias` replacer that was adding `/index.js` onto the `@mui/Xxxx` imports since MUI 7 has proper ESM support
 
 # 6.0.0-beta.9
 

packages/utils/src/schema/getDefaultFormState.ts

@@ -650,7 +650,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   const fillerDefault = fillerSchema.default;
 
   // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-  const fillerEntries: T[] = new Array(schema.minItems - defaultsLength).fill(
+  const fillerEntries: T[] = Array.from({ length: schema.minItems - defaultsLength }, () =>
     computeDefaults<any, S, F>(validator, fillerSchema, {
       parentDefaults: fillerDefault,
       rootSchema,

packages/utils/test/schema/getDefaultFormStateTest.ts

@@ -5004,5 +5004,171 @@ export default function getDefaultFormStateTest(testValidator: TestValidatorType
         empty: null,
       });
     });
+
+    describe('array object reference sharing fix (issue #4756)', () => {
+      const schema: RJSFSchema = {
+        type: 'object',
+        properties: {
+          config: {
+            oneOf: [
+              {
+                title: 'List Configuration',
+                properties: {
+                  items: {
+                    type: 'array',
+                    minItems: 2,
+                    items: {
+                      type: 'object',
+                      properties: {
+                        field: {
+                          type: 'string',
+                        },
+                      },
+                    },
+                  },
+                },
+                required: ['items'],
+              },
+            ],
+          },
+        },
+      };
+
+      it('should create independent object instances for array items via getDefaultFormState', () => {
+        const result = getDefaultFormState(testValidator, schema, undefined, schema);
+
+        expect(result).toStrictEqual({ config: { items: [{}, {}] } });
+
+        // Verify that modifying properties of one array item doesn't affect others
+        expect(result.config.items).toBeDefined();
+        expect(Array.isArray(result.config.items)).toBe(true);
+
+        // Verify objects are independent instances - modifying one shouldn't affect the other
+        (result.config.items[0] as any).field = 'test-value-1';
+        expect((result.config.items[1] as any).field).toBeUndefined();
+        expect(result.config.items[0]).not.toBe(result.config.items[1]);
+      });
+
+      it('should create independent object instances for array items via computeDefaults', () => {
+        const result = computeDefaults(testValidator, schema, {
+          rootSchema: schema,
+        });
+
+        expect(result).toStrictEqual({ config: { items: [{}, {}] } });
+
+        // Verify that modifying properties of one array item doesn't affect others
+        expect(result.config.items).toBeDefined();
+        expect(Array.isArray(result.config.items)).toBe(true);
+
+        // Verify objects are independent instances - modifying one shouldn't affect the other
+        (result.config.items[0] as any).field = 'test-value-1';
+        expect((result.config.items[1] as any).field).toBeUndefined();
+        expect(result.config.items[0]).not.toBe(result.config.items[1]);
+      });
+
+      it('should create independent object instances for array items via getArrayDefaults', () => {
+        const arraySchema: RJSFSchema = {
+          type: 'array',
+          minItems: 3,
+          items: {
+            type: 'object',
+            properties: {
+              field: {
+                type: 'string',
+              },
+            },
+          },
+        };
+
+        const result = getArrayDefaults(testValidator, arraySchema, {
+          rootSchema: arraySchema,
+        });
+
+        expect(result).toStrictEqual([{}, {}, {}]);
+
+        // Verify that array exists and objects are independent
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+
+        // Verify objects are independent instances
+        (result[0] as any).field = 'test-value-1';
+        (result[1] as any).field = 'test-value-2';
+        expect((result[2] as any).field).toBeUndefined();
+        expect(result[0]).not.toBe(result[1]);
+        expect(result[1]).not.toBe(result[2]);
+        expect(result[0]).not.toBe(result[2]);
+      });
+
+      it('should ensure array items with default values are independent instances', () => {
+        const arraySchemaWithDefaults: RJSFSchema = {
+          type: 'array',
+          minItems: 2,
+          items: {
+            type: 'object',
+            properties: {
+              field: {
+                type: 'string',
+                default: 'default-value',
+              },
+            },
+          },
+        };
+
+        const result = getArrayDefaults(testValidator, arraySchemaWithDefaults, {
+          rootSchema: arraySchemaWithDefaults,
+        });
+
+        expect(result).toStrictEqual([{ field: 'default-value' }, { field: 'default-value' }]);
+
+        // Verify that array exists and objects are independent
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+
+        // Verify objects are independent instances - modifying one shouldn't affect the other
+        (result[0] as any).field = 'modified-value';
+        expect((result[1] as any).field).toBe('default-value');
+        expect(result[0]).not.toBe(result[1]);
+      });
+
+      it('should ensure nested objects in arrays are independent instances', () => {
+        const nestedObjectSchema: RJSFSchema = {
+          type: 'array',
+          minItems: 2,
+          items: {
+            type: 'object',
+            properties: {
+              nested: {
+                type: 'object',
+                properties: {
+                  value: {
+                    type: 'string',
+                    default: 'nested-default',
+                  },
+                },
+              },
+            },
+          },
+        };
+
+        const result = getArrayDefaults(testValidator, nestedObjectSchema, {
+          rootSchema: nestedObjectSchema,
+        });
+
+        expect(result).toStrictEqual([
+          { nested: { value: 'nested-default' } },
+          { nested: { value: 'nested-default' } },
+        ]);
+
+        // Verify that array exists and nested objects are independent
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+
+        // Verify nested objects are independent instances
+        (result[0] as any).nested.value = 'modified-nested-value';
+        expect((result[1] as any).nested.value).toBe('nested-default');
+        expect(result[0]).not.toBe(result[1]);
+        expect((result[0] as any).nested).not.toBe((result[1] as any).nested);
+      });
+    });
   });
 }