@rjsf/utils 6.0.0-alpha.0 → 6.0.0-beta.1

package/src/schema/sanitizeDataForNewSchema.ts

@@ -1,7 +1,14 @@
 import get from 'lodash/get';
 import has from 'lodash/has';
 
-import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  GenericObjectType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import { PROPERTIES_KEY, REF_KEY } from '../constants';
 import retrieveSchema from './retrieveSchema';
 
@@ -51,14 +58,22 @@ const NO_VALUE = Symbol('no Value');
  * @param [newSchema] - The new schema for which the data is being sanitized
  * @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
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @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.
  */
 export default function sanitizeDataForNewSchema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, rootSchema: S, newSchema?: S, oldSchema?: S, data: any = {}): T {
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  newSchema?: S,
+  oldSchema?: S,
+  data: any = {},
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): T {
   // By default, we will clear the form data
   let newFormData;
   // If the new schema is of type object and that object contains a list of properties
@@ -78,14 +93,26 @@ export default function sanitizeDataForNewSchema<
     const nestedData: GenericObjectType = {};
     keys.forEach((key) => {
       const formValue = get(data, key);
-      let oldKeyedSchema: S = get(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema: S = get(newSchema, [PROPERTIES_KEY, key], {});
+      let oldKeyedSchema: S = get(oldSchema, [PROPERTIES_KEY, key], {}) as S;
+      let newKeyedSchema: S = get(newSchema, [PROPERTIES_KEY, key], {}) as S;
       // Resolve the refs if they exist
       if (has(oldKeyedSchema, REF_KEY)) {
-        oldKeyedSchema = retrieveSchema<T, S, F>(validator, oldKeyedSchema, rootSchema, formValue);
+        oldKeyedSchema = retrieveSchema<T, S, F>(
+          validator,
+          oldKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf,
+        );
       }
       if (has(newKeyedSchema, REF_KEY)) {
-        newKeyedSchema = retrieveSchema<T, S, F>(validator, newKeyedSchema, rootSchema, formValue);
+        newKeyedSchema = retrieveSchema<T, S, F>(
+          validator,
+          newKeyedSchema,
+          rootSchema,
+          formValue,
+          experimental_customMergeAllOf,
+        );
       }
       // Now get types and see if they are the same
       const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
@@ -104,7 +131,8 @@ export default function sanitizeDataForNewSchema<
             rootSchema,
             newKeyedSchema,
             oldKeyedSchema,
-            formValue
+            formValue,
+            experimental_customMergeAllOf,
           );
           if (itemData !== undefined || newSchemaTypeForKey === 'array') {
             // only put undefined values for the array type and not the object type
@@ -154,10 +182,22 @@ export default function sanitizeDataForNewSchema<
       !Array.isArray(newSchemaItems)
     ) {
       if (has(oldSchemaItems, REF_KEY)) {
-        oldSchemaItems = retrieveSchema<T, S, F>(validator, oldSchemaItems as S, rootSchema, data as T);
+        oldSchemaItems = retrieveSchema<T, S, F>(
+          validator,
+          oldSchemaItems as S,
+          rootSchema,
+          data as T,
+          experimental_customMergeAllOf,
+        );
       }
       if (has(newSchemaItems, REF_KEY)) {
-        newSchemaItems = retrieveSchema<T, S, F>(validator, newSchemaItems as S, rootSchema, data as T);
+        newSchemaItems = retrieveSchema<T, S, F>(
+          validator,
+          newSchemaItems as S,
+          rootSchema,
+          data as T,
+          experimental_customMergeAllOf,
+        );
       }
       // Now get types and see if they are the same
       const oldSchemaType = get(oldSchemaItems, 'type');
@@ -172,7 +212,8 @@ export default function sanitizeDataForNewSchema<
               rootSchema,
               newSchemaItems as S,
               oldSchemaItems as S,
-              aValue
+              aValue,
+              experimental_customMergeAllOf,
             );
             if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
               newValue.push(itemValue);

package/src/schema/toIdSchema.ts

@@ -1,11 +1,18 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 
 import { ALL_OF_KEY, DEPENDENCIES_KEY, ID_KEY, ITEMS_KEY, PROPERTIES_KEY, REF_KEY } from '../constants';
-import isObject from '../isObject';
-import { FormContextType, GenericObjectType, IdSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  GenericObjectType,
+  IdSchema,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import retrieveSchema from './retrieveSchema';
 import getSchemaType from '../getSchemaType';
+import deepEquals from '../deepEquals';
 
 /** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against
  * infinite recursion
@@ -18,6 +25,7 @@ import getSchemaType from '../getSchemaType';
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The `IdSchema` object for the `schema`
  */
 function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -28,54 +36,60 @@ function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F
   id?: string | null,
   rootSchema?: S,
   formData?: T,
-  _recurseList: S[] = []
+  _recurseList: S[] = [],
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): IdSchema<T> {
-  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
-    if (sameSchemaIndex === -1) {
+  const $id = id || idPrefix;
+  const idSchema: IdSchema<T> = { $id } as IdSchema<T>;
+  if (typeof schema === 'object') {
+    if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
+      const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+      const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+      if (sameSchemaIndex === -1) {
+        return toIdSchemaInternal<T, S, F>(
+          validator,
+          _schema,
+          idPrefix,
+          idSeparator,
+          id,
+          rootSchema,
+          formData,
+          _recurseList.concat(_schema),
+          experimental_customMergeAllOf,
+        );
+      }
+    }
+    if (ITEMS_KEY in schema && !get(schema, [ITEMS_KEY, REF_KEY])) {
       return toIdSchemaInternal<T, S, F>(
         validator,
-        _schema,
+        get(schema, ITEMS_KEY) as S,
         idPrefix,
         idSeparator,
         id,
         rootSchema,
         formData,
-        _recurseList.concat(_schema)
+        _recurseList,
+        experimental_customMergeAllOf,
       );
     }
-  }
-  if (ITEMS_KEY in schema && !get(schema, [ITEMS_KEY, REF_KEY])) {
-    return toIdSchemaInternal<T, S, F>(
-      validator,
-      get(schema, ITEMS_KEY) as S,
-      idPrefix,
-      idSeparator,
-      id,
-      rootSchema,
-      formData,
-      _recurseList
-    );
-  }
-  const $id = id || idPrefix;
-  const idSchema: IdSchema<T> = { $id } as IdSchema<T>;
-  if (getSchemaType<S>(schema) === 'object' && PROPERTIES_KEY in schema) {
-    for (const name in schema.properties) {
-      const field = get(schema, [PROPERTIES_KEY, name]);
-      const fieldId = idSchema[ID_KEY] + idSeparator + name;
-      (idSchema as IdSchema<GenericObjectType>)[name] = toIdSchemaInternal<T, S, F>(
-        validator,
-        isObject(field) ? field : {},
-        idPrefix,
-        idSeparator,
-        fieldId,
-        rootSchema,
-        // It's possible that formData is not an object -- this can happen if an
-        // array item has just been added, but not populated with data yet
-        get(formData, [name]),
-        _recurseList
-      );
+    if (getSchemaType<S>(schema) === 'object' && PROPERTIES_KEY in schema) {
+      for (const name in schema.properties) {
+        const field: S = schema[PROPERTIES_KEY][name] as S;
+        const fieldId = idSchema[ID_KEY] + idSeparator + name;
+        (idSchema as IdSchema<GenericObjectType>)[name] = toIdSchemaInternal<T, S, F>(
+          validator,
+          field,
+          idPrefix,
+          idSeparator,
+          fieldId,
+          rootSchema,
+          // It's possible that formData is not an object -- this can happen if an
+          // array item has just been added, but not populated with data yet
+          get(formData, [name]),
+          _recurseList,
+          experimental_customMergeAllOf,
+        );
+      }
     }
   }
   return idSchema;
@@ -90,6 +104,7 @@ function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @param [idPrefix='root'] - The prefix to use for the id
  * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The `IdSchema` object for the `schema`
  */
 export default function toIdSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -99,7 +114,18 @@ export default function toIdSchema<T = any, S extends StrictRJSFSchema = RJSFSch
   rootSchema?: S,
   formData?: T,
   idPrefix = 'root',
-  idSeparator = '_'
+  idSeparator = '_',
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): IdSchema<T> {
-  return toIdSchemaInternal<T, S, F>(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
+  return toIdSchemaInternal<T, S, F>(
+    validator,
+    schema,
+    idPrefix,
+    idSeparator,
+    id,
+    rootSchema,
+    formData,
+    undefined,
+    experimental_customMergeAllOf,
+  );
 }

package/src/schema/toPathSchema.ts

@@ -1,11 +1,10 @@
 import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
 import set from 'lodash/set';
 
 import {
+  ADDITIONAL_PROPERTIES_KEY,
   ALL_OF_KEY,
   ANY_OF_KEY,
-  ADDITIONAL_PROPERTIES_KEY,
   DEPENDENCIES_KEY,
   ITEMS_KEY,
   NAME_KEY,
@@ -15,9 +14,18 @@ import {
   RJSF_ADDITIONAL_PROPERTIES_FLAG,
 } from '../constants';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import { FormContextType, GenericObjectType, PathSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  GenericObjectType,
+  PathSchema,
+  RJSFSchema,
+  StrictRJSFSchema,
+  ValidatorType,
+} from '../types';
 import getClosestMatchingOption from './getClosestMatchingOption';
 import retrieveSchema from './retrieveSchema';
+import deepEquals from '../deepEquals';
 
 /** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
  * infinite recursion
@@ -28,6 +36,7 @@ import retrieveSchema from './retrieveSchema';
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [formData] - The current formData, if any, to assist retrieving a schema
  * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - The `PathSchema` object for the `schema`
  */
 function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -36,11 +45,12 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   name: string,
   rootSchema?: S,
   formData?: T,
-  _recurseList: S[] = []
+  _recurseList: S[] = [],
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): PathSchema<T> {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
+    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal<T, S, F>(
         validator,
@@ -48,7 +58,8 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
         name,
         rootSchema,
         formData,
-        _recurseList.concat(_schema)
+        _recurseList.concat(_schema),
+        experimental_customMergeAllOf,
       );
     }
   }
@@ -60,11 +71,27 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
     const xxxOf: S[] = ONE_OF_KEY in schema ? (schema.oneOf as S[]) : (schema.anyOf as S[]);
     const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
-    const index = getClosestMatchingOption<T, S, F>(validator, rootSchema!, formData, xxxOf, 0, discriminator);
+    const index = getClosestMatchingOption<T, S, F>(
+      validator,
+      rootSchema!,
+      formData,
+      xxxOf,
+      0,
+      discriminator,
+      experimental_customMergeAllOf,
+    );
     const _schema: S = xxxOf![index] as S;
     pathSchema = {
       ...pathSchema,
-      ...toPathSchemaInternal<T, S, F>(validator, _schema, name, rootSchema, formData, _recurseList),
+      ...toPathSchemaInternal<T, S, F>(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList,
+        experimental_customMergeAllOf,
+      ),
     };
   }
 
@@ -84,7 +111,8 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf,
           );
         } else if (schemaAdditionalItems) {
           (pathSchema as PathSchema<T[]>)[i] = toPathSchemaInternal<T, S, F>(
@@ -93,7 +121,8 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
             `${name}.${i}`,
             rootSchema,
             element,
-            _recurseList
+            _recurseList,
+            experimental_customMergeAllOf,
           );
         } else {
           console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
@@ -107,13 +136,14 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
           `${name}.${i}`,
           rootSchema,
           element,
-          _recurseList
+          _recurseList,
+          experimental_customMergeAllOf,
         );
       });
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get(schema, [PROPERTIES_KEY, property]);
+      const field: S = get(schema, [PROPERTIES_KEY, property], {}) as S;
       (pathSchema as PathSchema<GenericObjectType>)[property] = toPathSchemaInternal<T, S, F>(
         validator,
         field,
@@ -122,7 +152,8 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
         get(formData, [property]),
-        _recurseList
+        _recurseList,
+        experimental_customMergeAllOf,
       );
     }
   }
@@ -136,6 +167,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
  * @param [name=''] - The base name for the schema
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @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
  * @returns - The `PathSchema` object for the `schema`
  */
 export default function toPathSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
@@ -143,7 +175,8 @@ export default function toPathSchema<T = any, S extends StrictRJSFSchema = RJSFS
   schema: S,
   name = '',
   rootSchema?: S,
-  formData?: T
+  formData?: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): PathSchema<T> {
-  return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, undefined, experimental_customMergeAllOf);
 }

package/src/toErrorList.ts

@@ -11,7 +11,7 @@ import { ErrorSchema, GenericObjectType, RJSFValidationError } from './types';
  */
 export default function toErrorList<T = any>(
   errorSchema?: ErrorSchema<T>,
-  fieldPath: string[] = []
+  fieldPath: string[] = [],
 ): RJSFValidationError[] {
   if (!errorSchema) {
     return [];
@@ -26,7 +26,7 @@ export default function toErrorList<T = any>(
           message,
           stack: `${property} ${message}`,
         };
-      })
+      }),
     );
   }
   return Object.keys(errorSchema).reduce((acc, key) => {