[core] Port rjsf-team/react-jsonschema-form#4757

Author: x0k

.changeset/late-adults-tan.md

@@ -0,0 +1,5 @@
+---
+"@sjsf/form": patch
+---
+
+Port https://github.com/rjsf-team/react-jsonschema-form/pull/4757

packages/form/src/core/default-state.test.ts

@@ -6297,4 +6297,201 @@ describe("getDefaultFormState2()", () => {
       empty: null,
     });
   });
+
+  describe("array object reference sharing fix (issue #4756)", () => {
+    const schema: Schema = {
+      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,
+        defaultMerger,
+        schema,
+        undefined,
+        schema
+      ) as any;
+
+      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, defaultMerger, schema, {
+        ...defaults,
+        rootSchema: schema,
+      }) as any;
+
+      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: Schema = {
+        type: "array",
+        minItems: 3,
+        items: {
+          type: "object",
+          properties: {
+            field: {
+              type: "string",
+            },
+          },
+        },
+      };
+
+      const result = getArrayDefaults(
+        testValidator,
+        defaultMerger,
+        arraySchema,
+        {
+          ...defaults,
+          rootSchema: arraySchema,
+        },
+        undefined
+      ) as any;
+
+      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: Schema = {
+        type: "array",
+        minItems: 2,
+        items: {
+          type: "object",
+          properties: {
+            field: {
+              type: "string",
+              default: "default-value",
+            },
+          },
+        },
+      };
+
+      const result = getArrayDefaults(
+        testValidator,
+        defaultMerger,
+        arraySchemaWithDefaults,
+        {
+          ...defaults,
+          rootSchema: arraySchemaWithDefaults,
+        },
+        undefined
+      ) as any;
+
+      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: Schema = {
+        type: "array",
+        minItems: 2,
+        items: {
+          type: "object",
+          properties: {
+            nested: {
+              type: "object",
+              properties: {
+                value: {
+                  type: "string",
+                  default: "nested-default",
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = getArrayDefaults(
+        testValidator,
+        defaultMerger,
+        nestedObjectSchema,
+        {
+          ...defaults,
+          rootSchema: nestedObjectSchema,
+        },
+        undefined
+      ) as any;
+
+      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);
+    });
+  });
 });

packages/form/src/core/default-state.ts

@@ -858,18 +858,20 @@ export function getArrayDefaults(
   const fillerDefault = fillerSchema.default;
 
   // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-  const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-    computeDefaults(validator, merger, fillerSchema, {
-      parentDefaults: fillerDefault,
-      rootSchema,
-      stack: stack,
-      experimental_defaultFormStateBehavior,
-      required,
-      includeUndefinedValues: false,
-      rawFormData: undefined,
-      isSchemaRoot: false,
-      shouldMergeDefaultsIntoFormData,
-    })
+  const fillerEntries = Array.from(
+    { length: schema.minItems - defaultsLength },
+    () =>
+      computeDefaults(validator, merger, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        stack: stack,
+        experimental_defaultFormStateBehavior,
+        required,
+        includeUndefinedValues: false,
+        rawFormData: undefined,
+        isSchemaRoot: false,
+        shouldMergeDefaultsIntoFormData,
+      })
   );
   // then fill up the rest with either the item default or empty, up to minItems
   return defaultsLength ? defaults!.concat(fillerEntries) : fillerEntries;