@rjsf/utils 6.0.0-beta.20 → 6.0.0-beta.22

package/src/schema/getDefaultFormState.ts

@@ -200,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
@@ -229,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);
@@ -363,6 +368,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       rawFormData: (rawFormData ?? formData) as T,
       required,
       shouldMergeDefaultsIntoFormData,
+      initialDefaultsGenerated,
     });
   }
 
@@ -463,6 +469,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     experimental_customMergeAllOf = undefined,
     required,
     shouldMergeDefaultsIntoFormData,
+    initialDefaultsGenerated,
   }: ComputeDefaultsProps<T, S> = {},
   defaults?: T | T[],
 ): T {
@@ -498,6 +505,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           rawFormData: get(formData, [key]),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated,
         });
 
         maybeAddDefaultToObject<T>(
@@ -515,7 +523,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
       },
       {},
     ) 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
@@ -545,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>(
@@ -579,7 +588,9 @@ 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 {
@@ -608,6 +619,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
         parentDefaults: item,
         required,
         shouldMergeDefaultsIntoFormData,
+        initialDefaultsGenerated,
       });
     }) as T[];
   }
@@ -628,6 +640,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
           parentDefaults: get(defaults, [idx]),
           required,
           shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated,
         });
       }) as T[];
 
@@ -661,7 +674,8 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     computeSkipPopulate<T, S, F>(validator, schema, rootSchema) ||
     schema.minItems <= defaultsLength
   ) {
-    arrayDefault = 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);
@@ -727,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<
@@ -741,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);
@@ -757,6 +773,8 @@ export default function getDefaultFormState<
     experimental_customMergeAllOf,
     rawFormData: formData,
     shouldMergeDefaultsIntoFormData: true,
+    initialDefaultsGenerated,
+    requiredAsRoot: true,
   });
 
   if (schema.type !== 'object' && isObject(schema.default)) {

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,
@@ -242,6 +247,7 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
     recurseList,
     formData,
     experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs,
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     // return the updatedSchemas array if it has either multiple schemas within it
@@ -270,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,
@@ -304,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>(
@@ -314,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>(
@@ -326,6 +334,7 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
       expandAllBranches,
       recurseList,
       experimental_customMergeAllOf,
+      resolveAnyOfOrOneOfRefs,
     );
   }
   return [schema];
@@ -337,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>(
@@ -344,6 +354,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   rootSchema: S,
   recurseList: string[],
   baseURI?: string,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S {
   if (!isObject(schema)) {
     return schema;
@@ -371,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,
@@ -387,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;
 }
 
@@ -442,7 +473,7 @@ 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>(
@@ -494,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.
  */
@@ -509,6 +541,7 @@ export function retrieveSchemaInternal<
   expandAllBranches = false,
   recurseList: string[] = [],
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+  resolveAnyOfOrOneOfRefs?: boolean,
 ): S[] {
   if (!isObject(schema)) {
     return [{} as S];
@@ -521,6 +554,7 @@ export function retrieveSchemaInternal<
     recurseList,
     rawFormData,
     experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs,
   );
   return resolvedSchemas.flatMap((s: S) => {
     let resolvedSchema = s;

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)
+  );
+}

package/src/toFieldPathId.ts

@@ -4,21 +4,31 @@ import { FieldPathId, FieldPathList, GlobalFormOptions } from './types';
 /** Constructs the `FieldPathId` for `fieldPath`. If `parentPathId` is provided, the `fieldPath` is appended to the end
  * of the parent path. Then the `ID_KEY` of the resulting `FieldPathId` is constructed from the `idPrefix` and
  * `idSeparator` contained within the `globalFormOptions`. If `fieldPath` is passed as an empty string, it will simply
- * generate the path from the `parentPath` (if provided) and the `idPrefix` and `idSeparator`
+ * generate the path from the `parentPath` (if provided) and the `idPrefix` and `idSeparator`. If a `nameGenerator`
+ * is provided in `globalFormOptions`, it will also generate the HTML `name` attribute.
  *
  * @param fieldPath - The property name or array index of the current field element
  * @param globalFormOptions - The `GlobalFormOptions` used to get the `idPrefix` and `idSeparator`
  * @param [parentPath] - The optional `FieldPathId` or `FieldPathList` of the parent element for this field element
+ * @param [isMultiValue] - Optional flag indicating this field accepts multiple values
  * @returns - The `FieldPathId` for the given `fieldPath` and the optional `parentPathId`
  */
 export default function toFieldPathId(
   fieldPath: string | number,
   globalFormOptions: GlobalFormOptions,
   parentPath?: FieldPathId | FieldPathList,
+  isMultiValue?: boolean,
 ): FieldPathId {
   const basePath = Array.isArray(parentPath) ? parentPath : parentPath?.path;
   const childPath = fieldPath === '' ? [] : [fieldPath];
   const path = basePath ? basePath.concat(...childPath) : childPath;
   const id = [globalFormOptions.idPrefix, ...path].join(globalFormOptions.idSeparator);
-  return { path, [ID_KEY]: id };
+
+  // Generate name attribute if nameGenerator is provided
+  let name: string | undefined;
+  if (globalFormOptions.nameGenerator && path.length > 0) {
+    name = globalFormOptions.nameGenerator(path, globalFormOptions.idPrefix, isMultiValue);
+  }
+
+  return { path, [ID_KEY]: id, ...(name !== undefined && { name }) };
 }