@rjsf/utils 5.11.2 → 5.12.0

package/src/schema/sanitizeDataForNewSchema.ts

@@ -0,0 +1,197 @@
+import get from 'lodash/get';
+import has from 'lodash/has';
+
+import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { PROPERTIES_KEY, REF_KEY } from '../constants';
+import retrieveSchema from './retrieveSchema';
+
+const NO_VALUE = Symbol('no Value');
+
+/** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new
+ * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature
+ * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema
+ * that are non-existent in the new schema are set to `undefined`. The data sanitization process has the following flow:
+ *
+ * - If the new schema is an object that contains a `properties` object then:
+ *   - Create a `removeOldSchemaData` object, setting each key in the `oldSchema.properties` having `data` to undefined
+ *   - Create an empty `nestedData` object for use in the key filtering below:
+ *   - Iterate over each key in the `newSchema.properties` as follows:
+ *     - Get the `formValue` of the key from the `data`
+ *     - Get the `oldKeySchema` and `newKeyedSchema` for the key, defaulting to `{}` when it doesn't exist
+ *     - Retrieve the schema for any refs within each `oldKeySchema` and/or `newKeySchema`
+ *     - Get the types of the old and new keyed schemas and if the old doesn't exist or the old & new are the same then:
+ *       - If `removeOldSchemaData` has an entry for the key, delete it since the new schema has the same property
+ *       - If type of the key in the new schema is `object`:
+ *         - Store the value from the recursive `sanitizeDataForNewSchema` call in `nestedData[key]`
+ *       - Otherwise, check for default or const values:
+ *         - Get the old and new `default` values from the schema and check:
+ *           - If the new `default` value does not match the form value:
+ *             - If the old `default` value DOES match the form value, then:
+ *               - Replace `removeOldSchemaData[key]` with the new `default`
+ *               - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined
+ *         - Get the old and new `const` values from the schema and check:
+ *           - If the new `const` value does not match the form value:
+ *           - If the old `const` value DOES match the form value, then:
+ *             - Replace `removeOldSchemaData[key]` with the new `const`
+ *             - Otherwise, replace `removeOldSchemaData[key]` with undefined
+ *   - Once all keys have been processed, return an object built as follows:
+ *     - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }`
+ * - If the new and old schema types are array and the `data` is an array then:
+ *   - If the type of the old and new schema `items` are a non-array objects:
+ *     - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items`
+ *     - If the `type`s of both items are the same (or the old does not have a type):
+ *       - If the type is "object", then:
+ *         - 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
+ * - Otherwise return `undefined`
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @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
+ * @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 {
+  // 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
+  if (has(newSchema, PROPERTIES_KEY)) {
+    // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data
+    const removeOldSchemaData: GenericObjectType = {};
+    if (has(oldSchema, PROPERTIES_KEY)) {
+      const properties = get(oldSchema, PROPERTIES_KEY, {});
+      Object.keys(properties).forEach((key) => {
+        if (has(data, key)) {
+          removeOldSchemaData[key] = undefined;
+        }
+      });
+    }
+    const keys: string[] = Object.keys(get(newSchema, PROPERTIES_KEY, {}));
+    // Create a place to store nested data that will be a side-effect of the filter
+    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], {});
+      // Resolve the refs if they exist
+      if (has(oldKeyedSchema, REF_KEY)) {
+        oldKeyedSchema = retrieveSchema<T, S, F>(validator, oldKeyedSchema, rootSchema, formValue);
+      }
+      if (has(newKeyedSchema, REF_KEY)) {
+        newKeyedSchema = retrieveSchema<T, S, F>(validator, newKeyedSchema, rootSchema, formValue);
+      }
+      // Now get types and see if they are the same
+      const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
+      const newSchemaTypeForKey = get(newKeyedSchema, 'type');
+      // Check if the old option has the same key with the same type
+      if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
+        if (has(removeOldSchemaData, key)) {
+          // SIDE-EFFECT: remove the undefined value for a key that has the same type between the old and new schemas
+          delete removeOldSchemaData[key];
+        }
+        // If it is an object, we'll recurse and store the resulting sanitized data for the key
+        if (newSchemaTypeForKey === 'object' || (newSchemaTypeForKey === 'array' && Array.isArray(formValue))) {
+          // SIDE-EFFECT: process the new schema type of object recursively to save iterations
+          const itemData = sanitizeDataForNewSchema<T, S, F>(
+            validator,
+            rootSchema,
+            newKeyedSchema,
+            oldKeyedSchema,
+            formValue
+          );
+          if (itemData !== undefined || newSchemaTypeForKey === 'array') {
+            // only put undefined values for the array type and not the object type
+            nestedData[key] = itemData;
+          }
+        } else {
+          // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced
+          // with the new default or const. This allows the case where two schemas differ that only by the default/const
+          // value to be properly selected
+          const newOptionDefault = get(newKeyedSchema, 'default', NO_VALUE);
+          const oldOptionDefault = get(oldKeyedSchema, 'default', NO_VALUE);
+          if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
+            if (oldOptionDefault === formValue) {
+              // If the old default matches the formValue, we'll update the new value to match the new default
+              removeOldSchemaData[key] = newOptionDefault;
+            } else if (get(newKeyedSchema, 'readOnly') === true) {
+              // If the new schema has the default set to read-only, treat it like a const and remove the value
+              removeOldSchemaData[key] = undefined;
+            }
+          }
+
+          const newOptionConst = get(newKeyedSchema, 'const', NO_VALUE);
+          const oldOptionConst = get(oldKeyedSchema, 'const', NO_VALUE);
+          if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
+            // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it
+            removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined;
+          }
+        }
+      }
+    });
+
+    newFormData = {
+      ...data,
+      ...removeOldSchemaData,
+      ...nestedData,
+    };
+    // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep
+  } else if (get(oldSchema, 'type') === 'array' && get(newSchema, 'type') === 'array' && Array.isArray(data)) {
+    let oldSchemaItems = get(oldSchema, 'items');
+    let newSchemaItems = get(newSchema, 'items');
+    // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data
+    // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations
+    if (
+      typeof oldSchemaItems === 'object' &&
+      typeof newSchemaItems === 'object' &&
+      !Array.isArray(oldSchemaItems) &&
+      !Array.isArray(newSchemaItems)
+    ) {
+      if (has(oldSchemaItems, REF_KEY)) {
+        oldSchemaItems = retrieveSchema<T, S, F>(validator, oldSchemaItems as S, rootSchema, data as T);
+      }
+      if (has(newSchemaItems, REF_KEY)) {
+        newSchemaItems = retrieveSchema<T, S, F>(validator, newSchemaItems as S, rootSchema, data as T);
+      }
+      // Now get types and see if they are the same
+      const oldSchemaType = get(oldSchemaItems, 'type');
+      const newSchemaType = get(newSchemaItems, 'type');
+      // Check if the old option has the same key with the same type
+      if (!oldSchemaType || oldSchemaType === newSchemaType) {
+        const maxItems = get(newSchema, 'maxItems', -1);
+        if (newSchemaType === 'object') {
+          newFormData = data.reduce((newValue, aValue) => {
+            const itemValue = sanitizeDataForNewSchema<T, S, F>(
+              validator,
+              rootSchema,
+              newSchemaItems as S,
+              oldSchemaItems as S,
+              aValue
+            );
+            if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
+              newValue.push(itemValue);
+            }
+            return newValue;
+          }, []);
+        } else {
+          newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data;
+        }
+      }
+    } else if (
+      typeof oldSchemaItems === 'boolean' &&
+      typeof newSchemaItems === 'boolean' &&
+      oldSchemaItems === newSchemaItems
+    ) {
+      // If they are both booleans and have the same value just return the data as is otherwise fall-thru to undefined
+      newFormData = data;
+    }
+    // Also probably want to deal with `prefixItems` as tuples with the latest 2020 draft
+  }
+  return newFormData as T;
+}

package/src/schema/toIdSchema.ts

@@ -0,0 +1,105 @@
+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, IdSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import retrieveSchema from './retrieveSchema';
+import getSchemaType from '../getSchemaType';
+
+/** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against
+ * infinite recursion
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `IdSchema` is desired
+ * @param idPrefix - The prefix to use for the id
+ * @param idSeparator - The separator to use for the path segments in the id
+ * @param [id] - The base id 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 [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
+ * @returns - The `IdSchema` object for the `schema`
+ */
+function toIdSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  idPrefix: string,
+  idSeparator: string,
+  id?: string | null,
+  rootSchema?: S,
+  formData?: T,
+  _recurseList: 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) {
+      return toIdSchemaInternal<T, S, F>(
+        validator,
+        _schema,
+        idPrefix,
+        idSeparator,
+        id,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema)
+      );
+    }
+  }
+  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 = { $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[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
+      );
+    }
+  }
+  return idSchema as IdSchema<T>;
+}
+
+/** Generates an `IdSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `IdSchema` is desired
+ * @param [id] - The base id 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 [idPrefix='root'] - The prefix to use for the id
+ * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @returns - The `IdSchema` object for the `schema`
+ */
+export default function toIdSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  id?: string | null,
+  rootSchema?: S,
+  formData?: T,
+  idPrefix = 'root',
+  idSeparator = '_'
+): IdSchema<T> {
+  return toIdSchemaInternal<T, S, F>(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
+}

package/src/schema/toPathSchema.ts

@@ -0,0 +1,121 @@
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import set from 'lodash/set';
+
+import {
+  ALL_OF_KEY,
+  ANY_OF_KEY,
+  ADDITIONAL_PROPERTIES_KEY,
+  DEPENDENCIES_KEY,
+  ITEMS_KEY,
+  NAME_KEY,
+  ONE_OF_KEY,
+  PROPERTIES_KEY,
+  REF_KEY,
+  RJSF_ADDITONAL_PROPERTIES_FLAG,
+} from '../constants';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
+import { FormContextType, PathSchema, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import getClosestMatchingOption from './getClosestMatchingOption';
+import retrieveSchema from './retrieveSchema';
+
+/** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
+ * infinite recursion
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `PathSchema` is desired
+ * @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 [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
+ * @returns - The `PathSchema` object for the `schema`
+ */
+function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  name: string,
+  rootSchema?: S,
+  formData?: T,
+  _recurseList: 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));
+    if (sameSchemaIndex === -1) {
+      return toPathSchemaInternal<T, S, F>(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema)
+      );
+    }
+  }
+
+  let pathSchema: PathSchema = {
+    [NAME_KEY]: name.replace(/^\./, ''),
+  } as PathSchema;
+
+  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 _schema: S = xxxOf![index] as S;
+    pathSchema = {
+      ...pathSchema,
+      ...toPathSchemaInternal<T, S, F>(validator, _schema, name, rootSchema, formData, _recurseList),
+    };
+  }
+
+  if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
+    set(pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
+  }
+
+  if (ITEMS_KEY in schema && Array.isArray(formData)) {
+    formData.forEach((element, i: number) => {
+      pathSchema[i] = toPathSchemaInternal<T, S, F>(
+        validator,
+        schema.items as S,
+        `${name}.${i}`,
+        rootSchema,
+        element,
+        _recurseList
+      );
+    });
+  } else if (PROPERTIES_KEY in schema) {
+    for (const property in schema.properties) {
+      const field = get(schema, [PROPERTIES_KEY, property]);
+      pathSchema[property] = toPathSchemaInternal<T, S, F>(
+        validator,
+        field,
+        `${name}.${property}`,
+        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, [property]),
+        _recurseList
+      );
+    }
+  }
+  return pathSchema as PathSchema<T>;
+}
+
+/** Generates an `PathSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `PathSchema` is desired
+ * @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
+ * @returns - The `PathSchema` object for the `schema`
+ */
+export default function toPathSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  name = '',
+  rootSchema?: S,
+  formData?: T
+): PathSchema<T> {
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
+}

package/src/schemaRequiresTrueValue.ts

@@ -0,0 +1,40 @@
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Check to see if a `schema` specifies that a value must be true. This happens when:
+ * - `schema.const` is truthy
+ * - `schema.enum` == `[true]`
+ * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true
+ * - `schema.allOf` has at least one value which recursively returns true
+ *
+ * @param schema - The schema to check
+ * @returns - True if the schema specifies a value that must be true, false otherwise
+ */
+export default function schemaRequiresTrueValue<S extends StrictRJSFSchema = RJSFSchema>(schema: S): boolean {
+  // Check if const is a truthy value
+  if (schema.const) {
+    return true;
+  }
+
+  // Check if an enum has a single value of true
+  if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
+    return true;
+  }
+
+  // If anyOf has a single value, evaluate the subschema
+  if (schema.anyOf && schema.anyOf.length === 1) {
+    return schemaRequiresTrueValue(schema.anyOf[0] as S);
+  }
+
+  // If oneOf has a single value, evaluate the subschema
+  if (schema.oneOf && schema.oneOf.length === 1) {
+    return schemaRequiresTrueValue(schema.oneOf[0] as S);
+  }
+
+  // Evaluate each subschema in allOf, to see if one of them requires a true value
+  if (schema.allOf) {
+    const schemaSome = (subSchema: S['additionalProperties']) => schemaRequiresTrueValue(subSchema as S);
+    return schema.allOf.some(schemaSome);
+  }
+
+  return false;
+}

package/src/shouldRender.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+
+import deepEquals from './deepEquals';
+
+/** 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.
+ *
+ * @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
+ * @returns - True if the component should be re-rendered, false otherwise
+ */
+export default function shouldRender(component: React.Component, nextProps: any, nextState: any) {
+  const { props, state } = component;
+  return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
+}

package/src/toConstant.ts

@@ -0,0 +1,19 @@
+import { CONST_KEY, ENUM_KEY } from './constants';
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
+ * throws an error.
+ *
+ * @param schema - The schema from which to obtain the constant value
+ * @returns - The constant value for the schema
+ * @throws - Error when the schema does not have a constant value
+ */
+export default function toConstant<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
+  if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
+    return schema.enum[0];
+  }
+  if (CONST_KEY in schema) {
+    return schema.const;
+  }
+  throw new Error('schema cannot be inferred as a constant');
+}

package/src/toDateString.ts

@@ -0,0 +1,15 @@
+import { DateObject } from './types';
+
+/** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
+ * removed.
+ *
+ * @param dateObject - The `DateObject` to convert to a date string
+ * @param [time=true] - Optional flag used to remove the time portion of the date string if false
+ * @returns - The UTC date string
+ */
+export default function toDateString(dateObject: DateObject, time = true) {
+  const { year, month, day, hour = 0, minute = 0, second = 0 } = dateObject;
+  const utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
+  const datetime = new Date(utcTime).toJSON();
+  return time ? datetime : datetime.slice(0, 10);
+}

package/src/toErrorList.ts

@@ -0,0 +1,41 @@
+import isPlainObject from 'lodash/isPlainObject';
+
+import { ERRORS_KEY } from './constants';
+import { ErrorSchema, GenericObjectType, RJSFValidationError } from './types';
+
+/** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+ *
+ * @param errorSchema - The `ErrorSchema` instance to convert
+ * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
+ * @returns - The list of `RJSFValidationErrors` extracted from the `errorSchema`
+ */
+export default function toErrorList<T = any>(
+  errorSchema?: ErrorSchema<T>,
+  fieldPath: string[] = []
+): RJSFValidationError[] {
+  if (!errorSchema) {
+    return [];
+  }
+  let errorList: RJSFValidationError[] = [];
+  if (ERRORS_KEY in errorSchema) {
+    errorList = errorList.concat(
+      errorSchema[ERRORS_KEY]!.map((message: string) => {
+        const property = `.${fieldPath.join('.')}`;
+        return {
+          property,
+          message,
+          stack: `${property} ${message}`,
+        };
+      })
+    );
+  }
+  return Object.keys(errorSchema).reduce((acc, key) => {
+    if (key !== ERRORS_KEY) {
+      const childSchema = (errorSchema as GenericObjectType)[key];
+      if (isPlainObject(childSchema)) {
+        acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
+      }
+    }
+    return acc;
+  }, errorList);
+}

package/src/toErrorSchema.ts

@@ -0,0 +1,43 @@
+import toPath from 'lodash/toPath';
+
+import { ErrorSchema, RJSFValidationError } from './types';
+import ErrorSchemaBuilder from './ErrorSchemaBuilder';
+
+/** Transforms a rjsf validation errors list:
+ * [
+ *   {property: '.level1.level2[2].level3', message: 'err a'},
+ *   {property: '.level1.level2[2].level3', message: 'err b'},
+ *   {property: '.level1.level2[4].level3', message: 'err b'},
+ * ]
+ * Into an error tree:
+ * {
+ *   level1: {
+ *     level2: {
+ *       2: {level3: {errors: ['err a', 'err b']}},
+ *       4: {level3: {errors: ['err b']}},
+ *     }
+ *   }
+ * };
+ *
+ * @param errors - The list of RJSFValidationError objects
+ * @returns - The `ErrorSchema` built from the list of `RJSFValidationErrors`
+ */
+export default function toErrorSchema<T = any>(errors: RJSFValidationError[]): ErrorSchema<T> {
+  const builder = new ErrorSchemaBuilder<T>();
+  if (errors.length) {
+    errors.forEach((error) => {
+      const { property, message } = error;
+      // When the property is the root element, just use an empty array for the path
+      const path = property === '.' ? [] : toPath(property);
+      // If the property is at the root (.level1) then toPath creates
+      // an empty array element at the first index. Remove it.
+      if (path.length > 0 && path[0] === '') {
+        path.splice(0, 1);
+      }
+      if (message) {
+        builder.addErrors(message, path);
+      }
+    });
+  }
+  return builder.ErrorSchema;
+}