@rjsf/utils 6.0.0-beta.9 → 6.0.0

package/src/schema/getDefaultFormState.ts

@@ -84,6 +84,24 @@ export function getInnerSchemaForArrayItem<S extends StrictRJSFSchema = RJSFSche
   return {} as S;
 }
 
+/** Checks if the given `schema` contains the `null` type along with another type AND if the `default` contained within
+ * the schema is `null` AND the `computedDefault` is empty. If all of those conditions are true, then the `schema`'s
+ * default should be `null` rather than `computedDefault`.
+ *
+ * @param schema - The schema to inspect
+ * @param computedDefault - The computed default for the schema
+ * @returns - Flag indicating whether a null should be returned instead of the computedDefault
+ */
+export function computeDefaultBasedOnSchemaTypeAndDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S,
+  computedDefault: T,
+) {
+  const { default: schemaDefault, type } = schema;
+  const shouldReturnNullAsDefault =
+    Array.isArray(type) && type.includes('null') && isEmpty(computedDefault) && schemaDefault === null;
+  return shouldReturnNullAsDefault ? (null as T) : computedDefault;
+}
+
 /** Either add `computedDefault` at `key` into `obj` or not add it based on its value, the value of
  * `includeUndefinedValues`, the value of `emptyObjectFields` and if its parent field is required. Generally undefined
  * `computedDefault` values are added only when `includeUndefinedValues` is either true/"excludeObjectChildren". If `
@@ -115,10 +133,18 @@ function maybeAddDefaultToObject<T = any>(
   isConst = false,
 ) {
   const { emptyObjectFields = 'populateAllDefaults' } = experimental_defaultFormStateBehavior;
-  if (includeUndefinedValues || isConst) {
-    // If includeUndefinedValues
+
+  if (includeUndefinedValues === true || isConst) {
+    // If includeUndefinedValues is explicitly true
     // Or if the schema has a const property defined, then we should always return the computedDefault since it's coming from the const.
     obj[key] = computedDefault;
+  } else if (includeUndefinedValues === 'excludeObjectChildren') {
+    // Fix for Issue #4709: When in 'excludeObjectChildren' mode, don't set primitive fields to empty objects
+    // Only add the computed default if it's not an empty object placeholder for a primitive field
+    if (!isObject(computedDefault) || !isEmpty(computedDefault)) {
+      obj[key] = computedDefault;
+    }
+    // If computedDefault is an empty object {}, don't add it - let the field stay undefined
   } else if (emptyObjectFields !== 'skipDefaults') {
     // If isParentRequired is undefined, then we are at the root level of the schema so defer to the requiredness of
     // the field key itself in the `requiredField` list
@@ -174,10 +200,14 @@ interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema>
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>;
   /** Optional flag, if true, indicates this schema was required in the parent schema. */
   required?: boolean;
+  /** Optional flag, if true, indicates this schema was required because it is the root. */
+  requiredAsRoot?: boolean;
   /** Optional flag, if true, It will merge defaults into formData.
    *  The formData should take precedence unless it's not valid. This is useful when for example the value from formData does not exist in the schema 'enum' property, in such cases we take the value from the defaults because the value from the formData is not valid.
    */
   shouldMergeDefaultsIntoFormData?: boolean;
+  /** Indicates whether initial defaults have been generated */
+  initialDefaultsGenerated?: boolean;
 }
 
 /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
@@ -203,6 +233,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     experimental_customMergeAllOf = undefined,
     required,
     shouldMergeDefaultsIntoFormData = false,
+    initialDefaultsGenerated,
   } = computeDefaultsProps;
   let formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
   const schema: S = isObject(rawSchema) ? rawSchema : ({} as S);
@@ -213,7 +244,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
   if (
-    schema[CONST_KEY] &&
+    schema[CONST_KEY] !== undefined &&
     experimental_defaultFormStateBehavior?.constAsDefaults !== 'never' &&
     !constIsAjvDataReference(schema)
   ) {
@@ -334,9 +365,10 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
       experimental_customMergeAllOf,
       parentDefaults: defaults as T | undefined,
-      rawFormData: formData as T,
+      rawFormData: (rawFormData ?? formData) as T,
       required,
       shouldMergeDefaultsIntoFormData,
+      initialDefaultsGenerated,
     });
   }
 
@@ -437,8 +469,9 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     experimental_customMergeAllOf = undefined,
     required,
     shouldMergeDefaultsIntoFormData,
+    initialDefaultsGenerated,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
+  defaults?: T | T[],
 ): T {
   {
     const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
@@ -472,7 +505,9 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           rawFormData: get(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated,
         });
+
         maybeAddDefaultToObject<T>(
           acc,
           key,
@@ -483,11 +518,12 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           experimental_defaultFormStateBehavior,
           hasConst,
         );
+
         return acc;
       },
       {},
     ) as T;
-    if (retrievedSchema.additionalProperties) {
+    if (retrievedSchema.additionalProperties && !initialDefaultsGenerated) {
       // as per spec additionalProperties may be either schema or boolean
       const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties)
         ? retrievedSchema.additionalProperties
@@ -517,6 +553,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           rawFormData: get(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated,
         });
         // Since these are additional properties we don't need to add the `experimental_defaultFormStateBehavior` prop
         maybeAddDefaultToObject<T>(
@@ -529,7 +566,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
         );
       });
     }
-    return objectDefaults;
+    return computeDefaultBasedOnSchemaTypeAndDefaults<T, S>(rawSchema, objectDefaults);
   }
 }
 
@@ -551,10 +588,12 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     experimental_defaultFormStateBehavior = undefined,
     experimental_customMergeAllOf = undefined,
     required,
+    requiredAsRoot = false,
     shouldMergeDefaultsIntoFormData,
+    initialDefaultsGenerated,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined,
-): T | T[] | undefined {
+  defaults?: T[],
+): T[] | undefined {
   const schema: S = rawSchema;
 
   const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
@@ -566,7 +605,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   const computeSkipPopulate = arrayMinItemsStateBehavior?.computeSkipPopulate ?? (() => false);
   const isSkipEmptyDefaults = experimental_defaultFormStateBehavior?.emptyObjectFields === 'skipEmptyDefaults';
 
-  const emptyDefault = isSkipEmptyDefaults ? undefined : [];
+  const emptyDefault: T[] | undefined = isSkipEmptyDefaults ? undefined : [];
 
   // Inject defaults into existing array defaults
   if (Array.isArray(defaults)) {
@@ -580,6 +619,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
         parentDefaults: item,
         required,
         shouldMergeDefaultsIntoFormData,
+        initialDefaultsGenerated,
       });
     }) as T[];
   }
@@ -588,7 +628,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
   if (Array.isArray(rawFormData)) {
     const schemaItem: S = getInnerSchemaForArrayItem<S>(schema);
     if (neverPopulate) {
-      defaults = rawFormData;
+      defaults = rawFormData as typeof defaults;
     } else {
       const itemDefaults = rawFormData.map((item: T, idx: number) => {
         return computeDefaults<T, S, F>(validator, schemaItem, {
@@ -600,6 +640,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
           parentDefaults: get(defaults, [idx]),
           required,
           shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated,
         });
       }) as T[];
 
@@ -625,6 +666,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     }
   }
 
+  let arrayDefault: T[] | undefined;
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (
     !schema.minItems ||
@@ -632,27 +674,30 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
     schema.minItems <= defaultsLength
   ) {
-    return defaults ? defaults : emptyDefault;
+    // we don't want undefined defaults unless it is both not required or not required as root
+    arrayDefault = defaults || (!required && !requiredAsRoot) ? defaults : emptyDefault;
+  } else {
+    const defaultEntries: T[] = (defaults || []) as T[];
+    const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
+    const fillerDefault = fillerSchema.default;
+
+    // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
+    const fillerEntries: T[] = Array.from({ length: schema.minItems - defaultsLength }, () =>
+      computeDefaults<any, S, F>(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
+        required,
+        shouldMergeDefaultsIntoFormData,
+      }),
+    ) as T[];
+    // then fill up the rest with either the item default or empty, up to minItems
+    arrayDefault = defaultEntries.concat(fillerEntries);
   }
 
-  const defaultEntries: T[] = (defaults || []) as T[];
-  const fillerSchema: S = getInnerSchemaForArrayItem<S>(schema, AdditionalItemsHandling.Invert);
-  const fillerDefault = fillerSchema.default;
-
-  // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-  const fillerEntries: T[] = new Array(schema.minItems - defaultsLength).fill(
-    computeDefaults<any, S, F>(validator, fillerSchema, {
-      parentDefaults: fillerDefault,
-      rootSchema,
-      _recurseList,
-      experimental_defaultFormStateBehavior,
-      experimental_customMergeAllOf,
-      required,
-      shouldMergeDefaultsIntoFormData,
-    }),
-  ) as T[];
-  // then fill up the rest with either the item default or empty, up to minItems
-  return defaultEntries.concat(fillerEntries);
+  return computeDefaultBasedOnSchemaTypeAndDefaults<T[] | undefined, S>(rawSchema, arrayDefault);
 }
 
 /** Computes the default value based on the schema type.
@@ -679,7 +724,7 @@ export function getDefaultBasedOnSchemaType<
       return getObjectDefaults(validator, rawSchema, computeDefaultsProps, defaults);
     }
     case 'array': {
-      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults);
+      return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults as T[]);
     }
   }
 }
@@ -696,6 +741,7 @@ export function getDefaultBasedOnSchemaType<
  *          false when computing defaults for any nested object properties.
  * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @param initialDefaultsGenerated - Optional flag, indicates whether or not initial defaults have been generated
  * @returns - The resulting `formData` with all the defaults provided
  */
 export default function getDefaultFormState<
@@ -710,6 +756,7 @@ export default function getDefaultFormState<
   includeUndefinedValues: boolean | 'excludeObjectChildren' = false,
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  initialDefaultsGenerated?: boolean,
 ) {
   if (!isObject(theSchema)) {
     throw new Error('Invalid schema: ' + theSchema);
@@ -726,8 +773,17 @@ export default function getDefaultFormState<
     experimental_customMergeAllOf,
     rawFormData: formData,
     shouldMergeDefaultsIntoFormData: true,
+    initialDefaultsGenerated,
+    requiredAsRoot: true,
   });
 
+  if (schema.type !== 'object' && isObject(schema.default)) {
+    return {
+      ...defaults,
+      ...formData,
+    } as T;
+  }
+
   // If the formData is an object or an array, add additional properties from formData and override formData with
   // defaults since the defaults are already merged with formData.
   if (isObject(formData) || Array.isArray(formData)) {

package/src/schema/getDisplayLabel.ts

@@ -52,10 +52,10 @@ export default function getDisplayLabel<
   if (schemaType === 'object') {
     displayLabel = false;
   }
-  if (schemaType === 'boolean' && !uiSchema[UI_WIDGET_KEY]) {
+  if (schemaType === 'boolean' && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
     displayLabel = false;
   }
-  if (uiSchema[UI_FIELD_KEY]) {
+  if (uiSchema && uiSchema[UI_FIELD_KEY]) {
     displayLabel = false;
   }
   return displayLabel;

package/src/schema/index.ts

@@ -10,7 +10,6 @@ import isMultiSelect from './isMultiSelect';
 import isSelect from './isSelect';
 import retrieveSchema from './retrieveSchema';
 import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
-import toIdSchema from './toIdSchema';
 import toPathSchema from './toPathSchema';
 
 export {
@@ -26,6 +25,5 @@ export {
   isSelect,
   retrieveSchema,
   sanitizeDataForNewSchema,
-  toIdSchema,
   toPathSchema,
 };

package/src/schema/retrieveSchema.ts

@@ -47,6 +47,7 @@ import isEmpty from 'lodash/isEmpty';
  * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
  * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @param [resolveAnyOfOrOneOfRefs = false] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
  * @returns - The schema having its conditions, additional properties, references and dependencies resolved
  */
 export default function retrieveSchema<
@@ -59,6 +60,7 @@ export default function retrieveSchema<
   rootSchema: S = {} as S,
   rawFormData?: T,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  resolveAnyOfOrOneOfRefs = false,
 ): S {
   return retrieveSchemaInternal<T, S, F>(
     validator,
@@ -68,6 +70,7 @@ export default function retrieveSchema<
     undefined,
     undefined,
     experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs,
   )[0];
 }
 
@@ -223,6 +226,7 @@ export function getMatchingPatternProperties<S extends StrictRJSFSchema = RJSFSc
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
  * @returns - The list of schemas having its references, dependencies and allOf schemas resolved
  */
 export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -233,6 +237,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
   recurseList: string[],
   formData?: T,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S[] {
   const updatedSchemas = resolveReference<T, S, F>(
     validator,
@@ -241,6 +246,8 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
     expandAllBranches,
     recurseList,
     formData,
+    experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs,
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     // return the updatedSchemas array if it has either multiple schemas within it
@@ -255,6 +262,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       expandAllBranches,
       recurseList,
       formData,
+      experimental_customMergeAllOf,
     );
     return resolvedSchemas.flatMap((s) => {
       return retrieveSchemaInternal<T, S, F>(
@@ -268,7 +276,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       );
     });
   }
-  if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
+  if (ALL_OF_KEY in schema && Array.isArray(schema[ALL_OF_KEY])) {
     const allOfSchemaElements: S[][] = schema.allOf.map((allOfSubschema) =>
       retrieveSchemaInternal<T, S, F>(
         validator,
@@ -302,6 +310,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
  * @param recurseList - The list of recursive references already processed
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
  * @returns - The list schemas retrieved after having all references resolved
  */
 export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -312,8 +321,9 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
   recurseList: string[],
   formData?: T,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S[] {
-  const updatedSchema = resolveAllReferences<S>(schema, rootSchema, recurseList);
+  const updatedSchema = resolveAllReferences<S>(schema, rootSchema, recurseList, undefined, resolveAnyOfOrOneOfRefs);
   if (updatedSchema !== schema) {
     // Only call this if the schema was actually changed by the `resolveAllReferences()` function
     return retrieveSchemaInternal<T, S, F>(
@@ -324,6 +334,7 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
       expandAllBranches,
       recurseList,
       experimental_customMergeAllOf,
+      resolveAnyOfOrOneOfRefs,
     );
   }
   return [schema];
@@ -335,6 +346,7 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @param recurseList - List of $refs already resolved to prevent recursion
  * @param [baseURI] - The base URI to be used for resolving relative references
+ * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
@@ -342,6 +354,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   rootSchema: S,
   recurseList: string[],
   baseURI?: string,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S {
   if (!isObject(schema)) {
     return schema;
@@ -369,7 +382,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
       resolvedSchema[PROPERTIES_KEY]!,
       (result, value, key: string) => {
         const childList: string[] = [...recurseList];
-        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI);
+        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI, resolveAnyOfOrOneOfRefs);
         childrenLists.push(childList);
       },
       {} as RJSFSchema,
@@ -385,10 +398,30 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   ) {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI),
+      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs),
     };
   }
 
+  if (resolveAnyOfOrOneOfRefs) {
+    let key: 'anyOf' | 'oneOf' | undefined;
+    let schemas: S[] | undefined;
+    if (ANY_OF_KEY in schema && Array.isArray(schema[ANY_OF_KEY])) {
+      key = ANY_OF_KEY;
+      schemas = resolvedSchema[ANY_OF_KEY] as S[];
+    } else if (ONE_OF_KEY in schema && Array.isArray(schema[ONE_OF_KEY])) {
+      key = ONE_OF_KEY;
+      schemas = resolvedSchema[ONE_OF_KEY] as S[];
+    }
+    if (key && schemas) {
+      resolvedSchema = {
+        ...resolvedSchema,
+        [key]: schemas.map((s: S) =>
+          resolveAllReferences(s, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs),
+        ),
+      };
+    }
+  }
+
   return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 
@@ -430,7 +463,7 @@ export function stubExistingAdditionalProperties<
       if (!isEmpty(matchingProperties)) {
         schema.properties[key] = retrieveSchema<T, S, F>(
           validator,
-          { allOf: Object.values(matchingProperties) } as S,
+          { [ALL_OF_KEY]: Object.values(matchingProperties) } as S,
           rootSchema,
           get(formData, [key]) as T,
           experimental_customMergeAllOf,
@@ -440,12 +473,12 @@ export function stubExistingAdditionalProperties<
       }
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
-      let additionalProperties: S['additionalProperties'] = {};
+      let additionalProperties: S['additionalProperties'];
       if (typeof schema.additionalProperties !== 'boolean') {
         if (REF_KEY in schema.additionalProperties!) {
           additionalProperties = retrieveSchema<T, S, F>(
             validator,
-            { $ref: get(schema.additionalProperties, [REF_KEY]) } as S,
+            { [REF_KEY]: get(schema.additionalProperties, [REF_KEY]) } as S,
             rootSchema,
             formData as T,
             experimental_customMergeAllOf,
@@ -492,6 +525,7 @@ export function stubExistingAdditionalProperties<
  *          dependencies as a list of schemas
  * @param [recurseList=[]] - The optional, list of recursive references already processed
  * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
  * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
  *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
  */
@@ -507,6 +541,7 @@ export function retrieveSchemaInternal<
   expandAllBranches = false,
   recurseList: string[] = [],
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S[] {
   if (!isObject(schema)) {
     return [{} as S];
@@ -519,6 +554,7 @@ export function retrieveSchemaInternal<
     recurseList,
     rawFormData,
     experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs,
   );
   return resolvedSchemas.flatMap((s: S) => {
     let resolvedSchema = s;

package/src/shallowEquals.ts

@@ -0,0 +1,41 @@
+/** Implements a shallow equals comparison that uses Object.is() for comparing values.
+ * This function compares objects by checking if all keys and their values are equal using Object.is().
+ *
+ * @param a - The first element to compare
+ * @param b - The second element to compare
+ * @returns - True if the `a` and `b` are shallow equal, false otherwise
+ */
+export default function shallowEquals(a: any, b: any): boolean {
+  // If they're the same reference, they're equal
+  if (Object.is(a, b)) {
+    return true;
+  }
+
+  // If either is null or undefined, they're not equal (since we know they're not the same reference)
+  if (a == null || b == null) {
+    return false;
+  }
+
+  // If they're not objects, they're not equal (since Object.is already checked)
+  if (typeof a !== 'object' || typeof b !== 'object') {
+    return false;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  // Different number of keys means not equal
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  // Check if all keys and values are equal
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/shouldRender.ts

@@ -1,16 +1,41 @@
 import React from 'react';
 
 import deepEquals from './deepEquals';
+import shallowEquals from './shallowEquals';
+
+/** The supported component update strategies */
+export type ComponentUpdateStrategy = 'customDeep' | 'shallow' | 'always';
 
 /** Determines whether the given `component` should be rerendered by comparing its current set of props and state
- * against the next set. If either of those two sets are not the same, then the component should be rerendered.
+ * against the next set. The comparison strategy can be controlled via the `updateStrategy` parameter.
  *
  * @param component - A React component being checked
  * @param nextProps - The next set of props against which to check
  * @param nextState - The next set of state against which to check
+ * @param updateStrategy - The strategy to use for comparison:
+ *   - 'customDeep': Uses RJSF's custom deep equality checks (default)
+ *   - 'shallow': Uses shallow comparison of props and state
+ *   - 'always': Always returns true (React's default behavior)
  * @returns - True if the component should be re-rendered, false otherwise
  */
-export default function shouldRender(component: React.Component, nextProps: any, nextState: any) {
+export default function shouldRender(
+  component: React.Component,
+  nextProps: any,
+  nextState: any,
+  updateStrategy: ComponentUpdateStrategy = 'customDeep',
+) {
+  if (updateStrategy === 'always') {
+    // Use React's default behavior: always update if state or props change (no shouldComponentUpdate optimization)
+    return true;
+  }
+
+  if (updateStrategy === 'shallow') {
+    // Use shallow comparison for props and state
+    const { props, state } = component;
+    return !shallowEquals(props, nextProps) || !shallowEquals(state, nextState);
+  }
+
+  // Use custom deep equality checks (default 'customDeep' strategy)
   const { props, state } = component;
   return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
 }

package/src/shouldRenderOptionalField.ts

@@ -0,0 +1,56 @@
+import isObject from 'lodash/isObject';
+import uniq from 'lodash/uniq';
+
+import { FormContextType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import getSchemaType from './getSchemaType';
+import getUiOptions from './getUiOptions';
+import isRootSchema from './isRootSchema';
+import { ANY_OF_KEY, ONE_OF_KEY } from './constants';
+
+/** Returns the unique list of schema types for all of the options in a anyOf/oneOf
+ *
+ * @param schemas - The list of schemas representing the XxxOf options
+ * @returns - All of the unique types contained within the oneOf list
+ */
+export function getSchemaTypesForXxxOf<S extends StrictRJSFSchema = RJSFSchema>(schemas: S[]): string | string[] {
+  const allTypes: string[] = uniq(
+    schemas
+      .map((s) => (isObject(s) ? getSchemaType(s) : undefined))
+      .flat()
+      .filter((t) => t !== undefined),
+  );
+  return allTypes.length === 1 ? allTypes[0] : allTypes;
+}
+
+/** Determines whether the field information from the combination of `schema` and `required` along with the
+ * `enableOptionalDataFieldForType` settings from the global UI options in the `registry` all indicate that this field
+ * should be rendered with the Optional Data Controls UI.
+ *
+ * @param registry - The `registry` object
+ * @param schema - The schema for the field
+ * @param required - Flag indicating whether the field is required
+ * @param [uiSchema] - The uiSchema for the field
+ * @return - True if the field should be rendered with the optional field UI, otherwise false
+ */
+export default function shouldRenderOptionalField<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(registry: Registry<T, S, F>, schema: S, required: boolean, uiSchema?: UiSchema<T, S, F>): boolean {
+  const { enableOptionalDataFieldForType = [] } = getUiOptions<T, S, F>(uiSchema, registry.globalUiOptions);
+  let schemaType: ReturnType<typeof getSchemaType<S>>;
+  if (ANY_OF_KEY in schema && Array.isArray(schema[ANY_OF_KEY])) {
+    schemaType = getSchemaTypesForXxxOf<S>(schema[ANY_OF_KEY] as S[]);
+  } else if (ONE_OF_KEY in schema && Array.isArray(schema[ONE_OF_KEY])) {
+    schemaType = getSchemaTypesForXxxOf<S>(schema[ONE_OF_KEY] as S[]);
+  } else {
+    schemaType = getSchemaType<S>(schema);
+  }
+  return (
+    !isRootSchema<T, S, F>(registry, schema) &&
+    !required &&
+    !!schemaType &&
+    !Array.isArray(schemaType) &&
+    !!enableOptionalDataFieldForType.find((val) => val === schemaType)
+  );
+}