Use default values when switching anyOf option

Author: quentin-sommer

packages/core/test/anyOf.test.jsx

@@ -165,6 +165,43 @@ describe('anyOf', () => {
     );
   });
 
+  it('should assign a default value and set defaults on option change for scalar types schemas', () => {
+    const { node, onChange } = createFormComponent({
+      schema: {
+        type: 'object',
+        properties: {
+          foo: {
+            anyOf: [
+              {
+                type: 'string',
+                default: 'defaultfoo',
+              },
+              {
+                type: 'boolean',
+                default: true,
+              },
+            ],
+          },
+        },
+      },
+    });
+    sinon.assert.calledWithMatch(onChange.lastCall, {
+      formData: { foo: 'defaultfoo' },
+    });
+
+    const $select = node.querySelector('select');
+
+    act(() => {
+      fireEvent.change($select, {
+        target: { value: $select.options[1].value },
+      });
+    });
+
+    sinon.assert.calledWithMatch(onChange.lastCall, {
+      formData: { foo: true },
+    });
+  });
+
   it('should assign a default value and set defaults on option change when using references', () => {
     const { node, onChange } = createFormComponent({
       schema: {

packages/utils/src/schema/sanitizeDataForNewSchema.ts

@@ -44,6 +44,8 @@ const NO_VALUE = Symbol('no Value');
  *         - For each element in the `data` recursively sanitize the data, stopping at `maxItems` if specified
  *       - Otherwise, just return the `data` removing any values after `maxItems` if it is set
  *   - If the type of the old and new schema `items` are booleans of the same value, return `data` as is
+ * - If the new schema contains a default value then:
+ *   - return the default value. We expect this to be a scalar value
  * - Otherwise return `undefined`
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
@@ -52,7 +54,8 @@ const NO_VALUE = Symbol('no Value');
  * @param [oldSchema] - The old schema from which the data originated
  * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
  * @returns - The new form data, with all the fields uniquely associated with the old schema set
- *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+ *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties
+ *      and doesn't provide a default value
  */
 export default function sanitizeDataForNewSchema<
   T = any,
@@ -193,5 +196,12 @@ export default function sanitizeDataForNewSchema<
     }
     // Also probably want to deal with `prefixItems` as tuples with the latest 2020 draft
   }
+  // Schema contains a single scalar value
+  else {
+    const newDefaultValue = get(newSchema, 'default');
+    if (newDefaultValue !== undefined) {
+      newFormData = newDefaultValue;
+    }
+  }
   return newFormData as T;
 }

packages/utils/test/schema/sanitizeDataForNewSchemaTest.ts

@@ -483,5 +483,16 @@ export default function sanitizeDataForNewSchemaTest(testValidator: TestValidato
       };
       expect(schemaUtils.sanitizeDataForNewSchema(newSchema, oldSchema, ['qwerty', 'asdfg'])).toEqual({});
     });
+
+    it('returns default value when new schema is a scalar schema', () => {
+      const oldSchema: RJSFSchema = {
+        type: 'string',
+      };
+      const newSchema: RJSFSchema = {
+        type: 'boolean',
+        default: true,
+      };
+      expect(schemaUtils.sanitizeDataForNewSchema(newSchema, oldSchema, 'oldValue')).toEqual(true);
+    });
   });
 }