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

package/src/createSchemaUtils.ts

@@ -1,8 +1,9 @@
 import deepEquals from './deepEquals';
 import {
-  ErrorSchema,
+  Experimental_CustomMergeAllOf,
   Experimental_DefaultFormStateBehavior,
   FormContextType,
+  FoundFieldType,
   GlobalUISchemaOptions,
   IdSchema,
   PathSchema,
@@ -10,19 +11,19 @@ import {
   SchemaUtilsType,
   StrictRJSFSchema,
   UiSchema,
-  ValidationData,
   ValidatorType,
 } from './types';
 import {
+  findFieldInSchema,
+  findSelectedOptionInXxxOf,
   getDefaultFormState,
   getDisplayLabel,
   getClosestMatchingOption,
   getFirstMatchingOption,
-  getMatchingOption,
+  getFromSchema,
   isFilesArray,
   isMultiSelect,
   isSelect,
-  mergeValidationData,
   retrieveSchema,
   sanitizeDataForNewSchema,
   toIdSchema,
@@ -30,9 +31,10 @@ import {
 } from './schema';
 
 /** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such
- * that one does not have to explicitly pass the `validator`, `rootSchema`, or `experimental_defaultFormStateBehavior` to each method.
- * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the
- * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface.
+ * that one does not have to explicitly pass the `validator`, `rootSchema`, `experimental_defaultFormStateBehavior` or
+ * `experimental_customMergeAllOf` to each method. Since these generally do not change across a `Form`, this allows for
+ * providing a simplified set of APIs to the `@rjsf/core` components and the various themes as well. This class
+ * implements the `SchemaUtilsType` interface.
  */
 class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>
   implements SchemaUtilsType<T, S, F>
@@ -40,21 +42,25 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
   rootSchema: S;
   validator: ValidatorType<T, S, F>;
   experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior;
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>;
 
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
    * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
    * @param rootSchema - The root schema that will be forwarded to all the APIs
    * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
+   * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
    */
   constructor(
     validator: ValidatorType<T, S, F>,
     rootSchema: S,
-    experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior
+    experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior,
+    experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
   ) {
     this.rootSchema = rootSchema;
     this.validator = validator;
     this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
+    this.experimental_customMergeAllOf = experimental_customMergeAllOf;
   }
 
   /** Returns the `ValidatorType` in the `SchemaUtilsType`
@@ -72,12 +78,14 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
    * @param rootSchema - The root schema that will be compared against the current one
    * @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
    * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
    */
   doesSchemaUtilsDiffer(
     validator: ValidatorType<T, S, F>,
     rootSchema: S,
-    experimental_defaultFormStateBehavior = {}
+    experimental_defaultFormStateBehavior = {},
+    experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
   ): boolean {
     if (!validator || !rootSchema) {
       return false;
@@ -85,7 +93,51 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
     return (
       this.validator !== validator ||
       !deepEquals(this.rootSchema, rootSchema) ||
-      !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior)
+      !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior) ||
+      this.experimental_customMergeAllOf !== experimental_customMergeAllOf
+    );
+  }
+
+  /** Finds the field specified by the `path` within the root or recursed `schema`. If there is no field for the specified
+   * `path`, then the default `{ field: undefined, isRequired: undefined }` is returned. It determines whether a leaf
+   * field is in the `required` list for its parent and if so, it is marked as required on return.
+   *
+   * @param schema - The current node within the JSON schema
+   * @param path - The remaining keys in the path to the desired field
+   * @param [formData] - The form data that is used to determine which oneOf option
+   * @returns - An object that contains the field and its required state. If no field can be found then
+   *            `{ field: undefined, isRequired: undefined }` is returned.
+   */
+  findFieldInSchema(schema: S, path: string | string[], formData?: T): FoundFieldType<S> {
+    return findFieldInSchema(
+      this.validator,
+      this.rootSchema,
+      schema,
+      path,
+      formData,
+      this.experimental_customMergeAllOf,
+    );
+  }
+
+  /** Finds the oneOf option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` that
+   * matches the `formData[selectorField]` value. For the purposes of this function, `selectorField` is either
+   * `schema.discriminator.propertyName` or `fallbackField`.
+   *
+   * @param schema - The schema element in which to search for the selected oneOf option
+   * @param fallbackField - The field to use as a backup selector field if the schema does not have a required field
+   * @param xxx - Either `oneOf` or `anyOf`, defines which value is being sought
+   * @param [formData={}] - The form data that is used to determine which oneOf option
+   * @returns - The anyOf/oneOf option that matches the selector field in the schema or undefined if nothing is selected
+   */
+  findSelectedOptionInXxxOf(schema: S, fallbackField: string, xxx: 'anyOf' | `oneOf`, formData: T): S | undefined {
+    return findSelectedOptionInXxxOf(
+      this.validator,
+      this.rootSchema,
+      schema,
+      fallbackField,
+      xxx,
+      formData,
+      this.experimental_customMergeAllOf,
     );
   }
 
@@ -102,7 +154,7 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
   getDefaultFormState(
     schema: S,
     formData?: T,
-    includeUndefinedValues: boolean | 'excludeObjectChildren' = false
+    includeUndefinedValues: boolean | 'excludeObjectChildren' = false,
   ): T | T[] | undefined {
     return getDefaultFormState<T, S, F>(
       this.validator,
@@ -110,7 +162,8 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
       formData,
       this.rootSchema,
       includeUndefinedValues,
-      this.experimental_defaultFormStateBehavior
+      this.experimental_defaultFormStateBehavior,
+      this.experimental_customMergeAllOf,
     );
   }
 
@@ -123,7 +176,14 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - True if the label should be displayed or false if it should not
    */
   getDisplayLabel(schema: S, uiSchema?: UiSchema<T, S, F>, globalOptions?: GlobalUISchemaOptions) {
-    return getDisplayLabel<T, S, F>(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
+    return getDisplayLabel<T, S, F>(
+      this.validator,
+      schema,
+      uiSchema,
+      this.rootSchema,
+      globalOptions,
+      this.experimental_customMergeAllOf,
+    );
   }
 
   /** Determines which of the given `options` provided most closely matches the `formData`.
@@ -143,7 +203,7 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
     formData: T | undefined,
     options: S[],
     selectedOption?: number,
-    discriminatorField?: string
+    discriminatorField?: string,
   ): number {
     return getClosestMatchingOption<T, S, F>(
       this.validator,
@@ -151,7 +211,8 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
       formData,
       options,
       selectedOption,
-      discriminatorField
+      discriminatorField,
+      this.experimental_customMergeAllOf,
     );
   }
 
@@ -168,18 +229,26 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
     return getFirstMatchingOption<T, S, F>(this.validator, formData, options, this.rootSchema, discriminatorField);
   }
 
-  /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
-   * Deprecated, use `getFirstMatchingOption()` instead.
+  /** Helper that acts like lodash's `get` but additionally retrieves `$ref`s as needed to get the path for schemas
+   * containing potentially nested `$ref`s.
    *
-   * @param formData - The current formData, if any, onto which to provide any missing defaults
-   * @param options - The list of options to find a matching options from
-   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-   *          determine which option is selected
-   * @returns - The index of the matched option or 0 if none is available
-   * @deprecated
+   * @param schema - The current node within the JSON schema recursion
+   * @param path - The remaining keys in the path to the desired property
+   * @param defaultValue - The value to return if a value is not found for the `pathList` path
+   * @returns - The internal schema from the `schema` for the given `path` or the `defaultValue` if not found
    */
-  getMatchingOption(formData: T | undefined, options: S[], discriminatorField?: string) {
-    return getMatchingOption<T, S, F>(this.validator, formData, options, this.rootSchema, discriminatorField);
+  getFromSchema(schema: S, path: string | string[], defaultValue: T): T;
+  getFromSchema(schema: S, path: string | string[], defaultValue: S): S;
+  getFromSchema(schema: S, path: string | string[], defaultValue: T | S): T | S {
+    return getFromSchema<T, S, F>(
+      this.validator,
+      this.rootSchema,
+      schema,
+      path,
+      // @ts-expect-error TS2769: No overload matches this call
+      defaultValue,
+      this.experimental_customMergeAllOf,
+    );
   }
 
   /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
@@ -189,7 +258,7 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - True if schema/uiSchema contains an array of files, otherwise false
    */
   isFilesArray(schema: S, uiSchema?: UiSchema<T, S, F>) {
-    return isFilesArray<T, S, F>(this.validator, schema, uiSchema, this.rootSchema);
+    return isFilesArray<T, S, F>(this.validator, schema, uiSchema, this.rootSchema, this.experimental_customMergeAllOf);
   }
 
   /** Checks to see if the `schema` combination represents a multi-select
@@ -198,7 +267,7 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - True if schema contains a multi-select, otherwise false
    */
   isMultiSelect(schema: S) {
-    return isMultiSelect<T, S, F>(this.validator, schema, this.rootSchema);
+    return isMultiSelect<T, S, F>(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
   }
 
   /** Checks to see if the `schema` combination represents a select
@@ -207,22 +276,7 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - True if schema contains a select, otherwise false
    */
   isSelect(schema: S) {
-    return isSelect<T, S, F>(this.validator, schema, this.rootSchema);
-  }
-
-  /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
-   * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
-   * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
-   * then `validationData` is returned.
-   *
-   * @param validationData - The current `ValidationData` into which to merge the additional errors
-   * @param [additionalErrorSchema] - The additional set of errors
-   * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
-   * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
-   *        removed in the next major release.
-   */
-  mergeValidationData(validationData: ValidationData<T>, additionalErrorSchema?: ErrorSchema<T>): ValidationData<T> {
-    return mergeValidationData<T, S, F>(this.validator, validationData, additionalErrorSchema);
+    return isSelect<T, S, F>(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
   }
 
   /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
@@ -234,7 +288,13 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - The schema having its conditions, additional properties, references and dependencies resolved
    */
   retrieveSchema(schema: S, rawFormData?: T) {
-    return retrieveSchema<T, S, F>(this.validator, schema, this.rootSchema, rawFormData);
+    return retrieveSchema<T, S, F>(
+      this.validator,
+      schema,
+      this.rootSchema,
+      rawFormData,
+      this.experimental_customMergeAllOf,
+    );
   }
 
   /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
@@ -249,7 +309,14 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
    */
   sanitizeDataForNewSchema(newSchema?: S, oldSchema?: S, data?: any): T {
-    return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+    return sanitizeDataForNewSchema(
+      this.validator,
+      this.rootSchema,
+      newSchema,
+      oldSchema,
+      data,
+      this.experimental_customMergeAllOf,
+    );
   }
 
   /** Generates an `IdSchema` object for the `schema`, recursively
@@ -262,7 +329,16 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - The `IdSchema` object for the `schema`
    */
   toIdSchema(schema: S, id?: string | null, formData?: T, idPrefix = 'root', idSeparator = '_'): IdSchema<T> {
-    return toIdSchema<T, S, F>(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
+    return toIdSchema<T, S, F>(
+      this.validator,
+      schema,
+      id,
+      this.rootSchema,
+      formData,
+      idPrefix,
+      idSeparator,
+      this.experimental_customMergeAllOf,
+    );
   }
 
   /** Generates an `PathSchema` object for the `schema`, recursively
@@ -273,7 +349,14 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
    * @returns - The `PathSchema` object for the `schema`
    */
   toPathSchema(schema: S, name?: string, formData?: T): PathSchema<T> {
-    return toPathSchema<T, S, F>(this.validator, schema, name, this.rootSchema, formData);
+    return toPathSchema<T, S, F>(
+      this.validator,
+      schema,
+      name,
+      this.rootSchema,
+      formData,
+      this.experimental_customMergeAllOf,
+    );
   }
 }
 
@@ -283,16 +366,23 @@ class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends Fo
  * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @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
  * @returns - An implementation of a `SchemaUtilsType` interface
  */
 export default function createSchemaUtils<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   rootSchema: S,
-  experimental_defaultFormStateBehavior = {}
+  experimental_defaultFormStateBehavior = {},
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): SchemaUtilsType<T, S, F> {
-  return new SchemaUtils<T, S, F>(validator, rootSchema, experimental_defaultFormStateBehavior);
+  return new SchemaUtils<T, S, F>(
+    validator,
+    rootSchema,
+    experimental_defaultFormStateBehavior,
+    experimental_customMergeAllOf,
+  );
 }

package/src/dataURItoBlob.ts

@@ -25,7 +25,7 @@ export default function dataURItoBlob(dataURILike: string) {
   const name = decodeURI(
     // parse the parameters into key-value pairs, find a key, and extract a value
     // if no key is found, then the name is unknown
-    mediaparams.map((param) => param.split('=')).find(([key]) => key === 'name')?.[1] || 'unknown'
+    mediaparams.map((param) => param.split('=')).find(([key]) => key === 'name')?.[1] || 'unknown',
   );
 
   // Built the Uint8Array Blob parameter from the base64 string.

package/src/dateRangeOptions.ts

@@ -12,7 +12,7 @@ import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
  */
 export default function dateRangeOptions<S extends StrictRJSFSchema = RJSFSchema>(
   start: number,
-  stop: number
+  stop: number,
 ): EnumOptionsType<S>[] {
   if (start <= 0 && stop <= 0) {
     start = new Date().getFullYear() + start;

package/src/enumOptionsDeselectValue.ts

@@ -1,7 +1,6 @@
-import isEqual from 'lodash/isEqual';
-
 import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+import deepEquals from './deepEquals';
 
 /** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
  * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is
@@ -18,11 +17,11 @@ import enumOptionsValueForIndex from './enumOptionsValueForIndex';
 export default function enumOptionsDeselectValue<S extends StrictRJSFSchema = RJSFSchema>(
   valueIndex: string | number,
   selected?: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
-  allEnumOptions: EnumOptionsType<S>[] = []
+  allEnumOptions: EnumOptionsType<S>[] = [],
 ): EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][] | undefined {
   const value = enumOptionsValueForIndex<S>(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter((v) => !isEqual(v, value));
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return isEqual(value, selected) ? undefined : selected;
+  return deepEquals(value, selected) ? undefined : selected;
 }

package/src/enumOptionsIndexForValue.ts

@@ -15,7 +15,7 @@ import enumOptionsIsSelected from './enumOptionsIsSelected';
 export default function enumOptionsIndexForValue<S extends StrictRJSFSchema = RJSFSchema>(
   value: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
   allEnumOptions: EnumOptionsType<S>[] = [],
-  multiple = false
+  multiple = false,
 ): string | string[] | undefined {
   const selectedIndexes: string[] = allEnumOptions
     .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined))

package/src/enumOptionsIsSelected.ts

@@ -1,6 +1,5 @@
-import isEqual from 'lodash/isEqual';
-
 import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import deepEquals from './deepEquals';
 
 /** Determines whether the given `value` is (one of) the `selected` value(s).
  *
@@ -10,10 +9,10 @@ import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
  */
 export default function enumOptionsIsSelected<S extends StrictRJSFSchema = RJSFSchema>(
   value: EnumOptionsType<S>['value'],
-  selected: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][]
+  selected: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
 ) {
   if (Array.isArray(selected)) {
-    return selected.some((sel) => isEqual(sel, value));
+    return selected.some((sel) => deepEquals(sel, value));
   }
-  return isEqual(selected, value);
+  return deepEquals(selected, value);
 }

package/src/enumOptionsSelectValue.ts

@@ -13,7 +13,7 @@ import isNil from 'lodash/isNil';
 export default function enumOptionsSelectValue<S extends StrictRJSFSchema = RJSFSchema>(
   valueIndex: string | number,
   selected: EnumOptionsType<S>['value'][],
-  allEnumOptions: EnumOptionsType<S>[] = []
+  allEnumOptions: EnumOptionsType<S>[] = [],
 ) {
   const value = enumOptionsValueForIndex<S>(valueIndex, allEnumOptions);
   if (!isNil(value)) {

package/src/enumOptionsValueForIndex.ts

@@ -14,7 +14,7 @@ import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
 export default function enumOptionsValueForIndex<S extends StrictRJSFSchema = RJSFSchema>(
   valueIndex: string | number | Array<string | number>,
   allEnumOptions: EnumOptionsType<S>[] = [],
-  emptyValue?: EnumOptionsType<S>['value']
+  emptyValue?: EnumOptionsType<S>['value'],
 ): EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][] | undefined {
   if (Array.isArray(valueIndex)) {
     return (

package/src/enums.ts

@@ -9,6 +9,8 @@ export enum TranslatableString {
   ArrayItemTitle = 'Item',
   /** Missing items reason, used by ArrayField */
   MissingItems = 'Missing items definition',
+  /** Empty array message, used by ArrayField */
+  EmptyArray = 'No items yet. Use the button below to add some.',
   /** Yes label, used by BooleanField */
   YesLabel = 'Yes',
   /** No label, used by BooleanField */

package/src/findSchemaDefinition.ts

@@ -1,8 +1,34 @@
 import jsonpointer from 'jsonpointer';
 import omit from 'lodash/omit';
 
-import { REF_KEY } from './constants';
+import { ID_KEY, JSON_SCHEMA_DRAFT_2020_12, REF_KEY, SCHEMA_KEY } from './constants';
 import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
+import isObject from 'lodash/isObject';
+import isEmpty from 'lodash/isEmpty';
+import UriResolver from 'fast-uri';
+import get from 'lodash/get';
+
+/** Looks for the `$id` pointed by `ref` in the schema definitions embedded in
+ * a JSON Schema bundle
+ *
+ * @param schema - The schema wherein `ref` should be searched
+ * @param ref - The `$id` of the reference to search for
+ * @returns - The schema matching the reference, or `undefined` if no match is found
+ */
+function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(schema: S, ref: string): S | undefined {
+  if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY] as string, ref)) {
+    return schema;
+  }
+  for (const subSchema of Object.values(schema)) {
+    if (isObject(subSchema)) {
+      const result = findEmbeddedSchemaRecursive<S>(subSchema as S, ref);
+      if (result !== undefined) {
+        return result as S;
+      }
+    }
+  }
+  return undefined;
+}
 
 /** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
  * location, the `object` minus the `key: value` and in the second location the `value`.
@@ -26,23 +52,40 @@ export function splitKeyElementFromObject(key: string, object: GenericObjectType
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param [baseURI=rootSchema['$id']] - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
 export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
   rootSchema: S = {} as S,
-  recurseList: string[] = []
+  recurseList: string[] = [],
+  baseURI: string | undefined = get(rootSchema, [ID_KEY]),
 ): S {
   const ref = $ref || '';
-  let decodedRef;
+  let current: S | undefined = undefined;
   if (ref.startsWith('#')) {
     // Decode URI fragment representation.
-    decodedRef = decodeURIComponent(ref.substring(1));
-  } else {
-    throw new Error(`Could not find a definition for ${$ref}.`);
+    const decodedRef = decodeURIComponent(ref.substring(1));
+    if (baseURI === undefined || (ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI)) {
+      current = jsonpointer.get(rootSchema, decodedRef);
+    } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      current = findEmbeddedSchemaRecursive<S>(rootSchema, baseURI.replace(/\/$/, ''));
+      if (current !== undefined) {
+        current = jsonpointer.get(current, decodedRef);
+      }
+    }
+  } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+    const resolvedRef = baseURI ? UriResolver.resolve(baseURI, ref) : ref;
+    const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, '').split('#');
+    current = findEmbeddedSchemaRecursive<S>(rootSchema, refId.replace(/\/$/, ''));
+    if (current !== undefined) {
+      baseURI = current[ID_KEY];
+      if (!isEmpty(refAnchor)) {
+        current = jsonpointer.get(current, decodeURIComponent(refAnchor.join('#')));
+      }
+    }
   }
-  const current: S = jsonpointer.get(rootSchema, decodedRef);
   if (current === undefined) {
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
@@ -58,7 +101,7 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
       throw new Error(`Definition for ${firstRef} contains a circular reference through ${circularPath}`);
     }
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
-    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref]);
+    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref], baseURI);
     if (Object.keys(remaining).length > 0) {
       return { ...remaining, ...subSchema };
     }
@@ -74,13 +117,15 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
  *
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
+ * @param [baseURI=rootSchema['$id']] - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
 export default function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
-  rootSchema: S = {} as S
+  rootSchema: S = {} as S,
+  baseURI: string | undefined = get(rootSchema, [ID_KEY]),
 ): S {
   const recurseList: string[] = [];
-  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
+  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }

package/src/getChangedFields.ts

@@ -0,0 +1,40 @@
+import keys from 'lodash/keys';
+import pickBy from 'lodash/pickBy';
+import isPlainObject from 'lodash/isPlainObject';
+import get from 'lodash/get';
+import difference from 'lodash/difference';
+import deepEquals from './deepEquals';
+
+/**
+ * Compares two objects and returns the names of the fields that have changed.
+ * This function iterates over each field of object `a`, using `_.isEqual` to compare the field value
+ * with the corresponding field value in object `b`. If the values are different, the field name will
+ * be included in the returned array.
+ *
+ * @param a - The first object, representing the original data to compare.
+ * @param b - The second object, representing the updated data to compare.
+ * @returns - An array of field names that have changed.
+ *
+ * @example
+ * const a = { name: 'John', age: 30 };
+ * const b = { name: 'John', age: 31 };
+ * const changedFields = getChangedFields(a, b);
+ * console.log(changedFields); // Output: ['age']
+ */
+export default function getChangedFields(a: unknown, b: unknown): string[] {
+  const aIsPlainObject = isPlainObject(a);
+  const bIsPlainObject = isPlainObject(b);
+  // If strictly equal or neither of them is a plainObject returns an empty array
+  if (a === b || (!aIsPlainObject && !bIsPlainObject)) {
+    return [];
+  }
+  if (aIsPlainObject && !bIsPlainObject) {
+    return keys(a);
+  } else if (!aIsPlainObject && bIsPlainObject) {
+    return keys(b);
+  } else {
+    const unequalFields = keys(pickBy(a as object, (value, key) => !deepEquals(value, get(b, key))));
+    const diffFields = difference(keys(b), keys(a));
+    return [...unequalFields, ...diffFields];
+  }
+}

package/src/getDateElementProps.ts

@@ -23,7 +23,7 @@ export default function getDateElementProps(
   date: DateObject,
   time: boolean,
   yearRange: [number, number] = [1900, new Date().getFullYear() + 2],
-  format: DateElementFormat = 'YMD'
+  format: DateElementFormat = 'YMD',
 ) {
   const { day, month, year, hour, minute, second } = date;
 
@@ -48,7 +48,7 @@ export default function getDateElementProps(
     dateElementProp.push(
       { type: 'hour', range: [0, 23], value: hour },
       { type: 'minute', range: [0, 59], value: minute },
-      { type: 'second', range: [0, 59], value: second }
+      { type: 'second', range: [0, 59], value: second },
     );
   }
 

package/src/getDiscriminatorFieldFromSchema.ts

@@ -2,6 +2,7 @@ import get from 'lodash/get';
 import isString from 'lodash/isString';
 
 import { RJSFSchema, StrictRJSFSchema } from './types';
+import { DISCRIMINATOR_PATH } from './constants';
 
 /** Returns the `discriminator.propertyName` when defined in the `schema` if it is a string. A warning is generated when
  * it is not a string. Returns `undefined` when a valid discriminator is not present.
@@ -11,7 +12,7 @@ import { RJSFSchema, StrictRJSFSchema } from './types';
  */
 export default function getDiscriminatorFieldFromSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
   let discriminator: string | undefined;
-  const maybeString = get(schema, 'discriminator.propertyName', undefined);
+  const maybeString = get(schema, DISCRIMINATOR_PATH);
   if (isString(maybeString)) {
     discriminator = maybeString;
   } else if (maybeString !== undefined) {