@rjsf/utils 5.24.10 → 6.0.0-beta.1

package/src/schema/findSelectedOptionInXxxOf.ts

@@ -0,0 +1,53 @@
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from '../constants';
+import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import retrieveSchema from './retrieveSchema';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
+
+/** Finds the option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` or
+ * `properties[selectorField].const` that matches the `formData[selectorField]` value. For the purposes of this
+ * function, `selectorField` is either `schema.discriminator.propertyName` or `fallbackField`. The `LayoutGridField`
+ * works directly with schemas in a recursive manner, making this faster than `getFirstMatchingOption()`.
+ *
+ * @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 schema - The schema element in which to search for the selected anyOf/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 `anyOf` or `oneOf`, defines which value is being sought
+ * @param [formData={}] - The form data that is used to determine which anyOf/oneOf option to descend
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @returns - The anyOf/oneOf option that matches the selector field in the schema or undefined if nothing is selected
+ */
+export default function findSelectedOptionInXxxOf<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  fallbackField: string,
+  xxx: 'anyOf' | 'oneOf',
+  formData: T = {} as T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): S | undefined {
+  if (Array.isArray(schema[xxx])) {
+    const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
+    const selectorField = discriminator || fallbackField;
+    const xxxOfs = schema[xxx]!.map((xxxOf) =>
+      retrieveSchema<T, S, F>(validator, xxxOf as S, rootSchema, formData, experimental_customMergeAllOf),
+    );
+    const data = get(formData, selectorField);
+    if (data !== undefined) {
+      return xxxOfs.find((xxx) => {
+        return isEqual(
+          get(xxx, [PROPERTIES_KEY, selectorField, DEFAULT_KEY], get(xxx, [PROPERTIES_KEY, selectorField, CONST_KEY])),
+          data,
+        );
+      });
+    }
+  }
+  return undefined;
+}

package/src/schema/getClosestMatchingOption.ts

@@ -53,7 +53,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
   rootSchema: S,
   schema?: S,
   formData?: any,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): number {
   let totalScore = 0;
   if (schema) {
@@ -71,7 +71,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
               value as S,
               rootSchema,
               formValue,
-              experimental_customMergeAllOf
+              experimental_customMergeAllOf,
             );
             return (
               score +
@@ -80,7 +80,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
                 rootSchema,
                 newSchema,
                 formValue || {},
-                experimental_customMergeAllOf
+                experimental_customMergeAllOf,
               )
             );
           }
@@ -96,7 +96,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
                 get(value, key) as S[],
                 -1,
                 discriminator,
-                experimental_customMergeAllOf
+                experimental_customMergeAllOf,
               )
             );
           }
@@ -127,7 +127,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
           }
           return score;
         },
-        0
+        0,
       );
     } else if (isString(schema.type) && schema.type === guessType(formData)) {
       totalScore += 1;
@@ -162,7 +162,7 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
 export default function getClosestMatchingOption<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   rootSchema: S,
@@ -170,7 +170,7 @@ export default function getClosestMatchingOption<
   options: S[],
   selectedOption = -1,
   discriminatorField?: string,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): number {
   // First resolve any refs in the options
   const resolvedOptions = options.map((option) => {
@@ -215,7 +215,7 @@ export default function getClosestMatchingOption<
       }
       return scoreData;
     },
-    { bestIndex: selectedOption, bestScore: 0 }
+    { bestIndex: selectedOption, bestScore: 0 },
   );
   // if all scores are the same go with selectedOption
   if (scoreCount.size === 1 && selectedOption >= 0) {

package/src/schema/getDefaultFormState.ts

@@ -66,7 +66,7 @@ export enum AdditionalItemsHandling {
 export function getInnerSchemaForArrayItem<S extends StrictRJSFSchema = RJSFSchema>(
   schema: S,
   additionalItems: AdditionalItemsHandling = AdditionalItemsHandling.Ignore,
-  idx = -1
+  idx = -1,
 ): S {
   if (idx >= 0) {
     if (Array.isArray(schema.items) && idx < schema.items.length) {
@@ -112,7 +112,7 @@ function maybeAddDefaultToObject<T = any>(
   isParentRequired?: boolean,
   requiredFields: string[] = [],
   experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior = {},
-  isConst = false
+  isConst = false,
 ) {
   const { emptyObjectFields = 'populateAllDefaults' } = experimental_defaultFormStateBehavior;
   if (includeUndefinedValues || isConst) {
@@ -191,7 +191,7 @@ interface ComputeDefaultsProps<T = any, S extends StrictRJSFSchema = RJSFSchema>
 export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   rawSchema: S,
-  computeDefaultsProps: ComputeDefaultsProps<T, S> = {}
+  computeDefaultsProps: ComputeDefaultsProps<T, S> = {},
 ): T | T[] | undefined {
   const {
     parentDefaults,
@@ -247,7 +247,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       false,
       [],
       defaultFormData,
-      experimental_customMergeAllOf
+      experimental_customMergeAllOf,
     );
     schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
   } else if (isFixedItems(schema)) {
@@ -262,7 +262,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         rawFormData: formData as T,
         required,
         shouldMergeDefaultsIntoFormData,
-      })
+      }),
     ) as T[];
   } else if (ONE_OF_KEY in schema) {
     const { oneOf, ...remaining } = schema;
@@ -290,7 +290,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         oneOf as S[],
         0,
         discriminator,
-        experimental_customMergeAllOf
+        experimental_customMergeAllOf,
       )
     ] as S;
     schemaToCompute = mergeSchemas(remaining, schemaToCompute) as S;
@@ -308,7 +308,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         anyOf as S[],
         0,
         discriminator,
-        experimental_customMergeAllOf
+        experimental_customMergeAllOf,
       )
     ] as S;
     schemaToCompute = mergeSchemas(remaining, schemaToCompute) as S;
@@ -347,7 +347,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
       rootSchema,
       rawFormData,
       experimental_defaultFormStateBehavior,
-      experimental_customMergeAllOf
+      experimental_customMergeAllOf,
     );
     if (!isObject(rawFormData) || ALL_OF_KEY in schema) {
       // If the formData is not an object which means it's a primitive field, then we need to merge the defaults into the formData.
@@ -356,7 +356,7 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
         defaultsWithFormData as T,
         matchingFormData as T,
         mergeExtraDefaults,
-        true
+        true,
       ) as T;
     }
   }
@@ -378,19 +378,20 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
 export function ensureFormDataMatchingSchema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   schema: S,
   rootSchema: S,
   formData: T | undefined,
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): T | T[] | undefined {
-  const isSelectField = !isConstant(schema) && isSelect(validator, schema, rootSchema, experimental_customMergeAllOf);
+  const isSelectField =
+    !isConstant<S>(schema) && isSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf);
   let validFormData: T | T[] | undefined = formData;
   if (isSelectField) {
-    const getOptionsList = optionsList(schema);
+    const getOptionsList = optionsList<T, S, F>(schema);
     const isValid = getOptionsList?.some((option) => deepEquals(option.value, formData));
     validFormData = isValid ? formData : undefined;
   }
@@ -425,7 +426,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     required,
     shouldMergeDefaultsIntoFormData,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined
+  defaults?: T | T[] | undefined,
 ): T {
   {
     const formData: T = (isObject(rawFormData) ? rawFormData : {}) as T;
@@ -439,7 +440,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc: GenericObjectType, key: string) => {
-        const propertySchema = get(retrievedSchema, [PROPERTIES_KEY, key]);
+        const propertySchema: S = get(retrievedSchema, [PROPERTIES_KEY, key], {}) as S;
         // Check if the parent schema has a const property defined AND we are supporting const as defaults, then we
         // should always return the computedDefault since it's coming from the const.
         const hasParentConst = isObject(parentConst) && (parentConst as JSONSchema7Object)[key] !== undefined;
@@ -468,11 +469,11 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           required,
           retrievedSchema.required,
           experimental_defaultFormStateBehavior,
-          hasConst
+          hasConst,
         );
         return acc;
       },
-      {}
+      {},
     ) as T;
     if (retrievedSchema.additionalProperties) {
       // as per spec additionalProperties may be either schema or boolean
@@ -512,7 +513,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           computedDefault,
           includeUndefinedValues,
           required,
-          formDataRequired
+          formDataRequired,
         );
       });
     }
@@ -540,7 +541,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
     required,
     shouldMergeDefaultsIntoFormData,
   }: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined
+  defaults?: T | T[] | undefined,
 ): T | T[] | undefined {
   const schema: S = rawSchema;
 
@@ -636,7 +637,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
       experimental_customMergeAllOf,
       required,
       shouldMergeDefaultsIntoFormData,
-    })
+    }),
   ) as T[];
   // then fill up the rest with either the item default or empty, up to minItems
   return defaultEntries.concat(fillerEntries);
@@ -653,12 +654,12 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
 export function getDefaultBasedOnSchemaType<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   rawSchema: S,
   computeDefaultsProps: ComputeDefaultsProps<T, S> = {},
-  defaults?: T | T[] | undefined
+  defaults?: T | T[] | undefined,
 ): T | T[] | void {
   switch (getSchemaType<S>(rawSchema)) {
     // We need to recurse for object schema inner default values.
@@ -688,7 +689,7 @@ export function getDefaultBasedOnSchemaType<
 export default function getDefaultFormState<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   theSchema: S,
@@ -696,7 +697,7 @@ export default function getDefaultFormState<
   rootSchema?: S,
   includeUndefinedValues: boolean | 'excludeObjectChildren' = false,
   experimental_defaultFormStateBehavior?: Experimental_DefaultFormStateBehavior,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
   if (!isObject(theSchema)) {
     throw new Error('Invalid schema: ' + theSchema);
@@ -725,7 +726,7 @@ export default function getDefaultFormState<
       formData,
       true, // set to true to add any additional default array entries.
       defaultSupercedesUndefined,
-      true // set to true to override formData with defaults if they exist.
+      true, // set to true to override formData with defaults if they exist.
     );
     return result;
   }

package/src/schema/getDisplayLabel.ts

@@ -28,14 +28,14 @@ import isMultiSelect from './isMultiSelect';
 export default function getDisplayLabel<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   schema: S,
   uiSchema: UiSchema<T, S, F> = {},
   rootSchema?: S,
   globalOptions?: GlobalUISchemaOptions,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): boolean {
   const uiOptions = getUiOptions<T, S, F>(uiSchema, globalOptions);
   const { label = true } = uiOptions;

package/src/schema/getFirstMatchingOption.ts

@@ -1,4 +1,9 @@
-import getMatchingOption from './getMatchingOption';
+import get from 'lodash/get';
+import has from 'lodash/has';
+import isNumber from 'lodash/isNumber';
+
+import { PROPERTIES_KEY } from '../constants';
+import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
 import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
 
 /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
@@ -15,13 +20,83 @@ import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '..
 export default function getFirstMatchingOption<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   formData: T | undefined,
   options: S[],
   rootSchema: S,
-  discriminatorField?: string
+  discriminatorField?: string,
 ): number {
-  return getMatchingOption<T, S, F>(validator, formData, options, rootSchema, discriminatorField);
+  // For performance, skip validating subschemas if formData is undefined. We just
+  // want to get the first option in that case.
+  if (formData === undefined) {
+    return 0;
+  }
+
+  const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
+  if (isNumber(simpleDiscriminatorMatch)) {
+    return simpleDiscriminatorMatch;
+  }
+
+  for (let i = 0; i < options.length; i++) {
+    const option = options[i];
+
+    // If we have a discriminator field, then we will use this to make the determination
+    if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
+      const value = get(formData, discriminatorField);
+      const discriminator: S = get(option, [PROPERTIES_KEY, discriminatorField], {}) as S;
+      if (validator.isValid(discriminator, value, rootSchema)) {
+        return i;
+      }
+    } else if (option[PROPERTIES_KEY]) {
+      // If the schema describes an object then we need to add slightly more
+      // strict matching to the schema, because unless the schema uses the
+      // "requires" keyword, an object will match the schema as long as it
+      // doesn't have matching keys with a conflicting type. To do this we use an
+      // "anyOf" with an array of requires. This augmentation expresses that the
+      // schema should match if any of the keys in the schema are present on the
+      // object and pass validation.
+      //
+      // Create an "anyOf" schema that requires at least one of the keys in the
+      // "properties" object
+      const requiresAnyOf = {
+        anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
+          required: [key],
+        })),
+      };
+
+      let augmentedSchema;
+
+      // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
+      if (option.anyOf) {
+        // Create a shallow clone of the option
+        const { ...shallowClone } = option;
+
+        if (!shallowClone.allOf) {
+          shallowClone.allOf = [];
+        } else {
+          // If "allOf" already exists, shallow clone the array
+          shallowClone.allOf = shallowClone.allOf.slice();
+        }
+
+        shallowClone.allOf.push(requiresAnyOf);
+
+        augmentedSchema = shallowClone;
+      } else {
+        augmentedSchema = Object.assign({}, option, requiresAnyOf);
+      }
+
+      // Remove the "required" field as it's likely that not all fields have
+      // been filled in yet, which will mean that the schema is not valid
+      delete augmentedSchema.required;
+
+      if (validator.isValid(augmentedSchema, formData, rootSchema)) {
+        return i;
+      }
+    } else if (validator.isValid(option, formData, rootSchema)) {
+      return i;
+    }
+  }
+  return 0;
 }

package/src/schema/getFromSchema.ts

@@ -0,0 +1,100 @@
+import get from 'lodash/get';
+import has from 'lodash/has';
+import isEmpty from 'lodash/isEmpty';
+
+import retrieveSchema from './retrieveSchema';
+import { Experimental_CustomMergeAllOf, FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { REF_KEY } from '../constants';
+
+/** Internal helper function 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 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 schema - The current node within the JSON schema recursion
+ * @param path - The remaining keys in the path to the desired property
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @returns - The internal schema from the `schema` for the given `path` or undefined if not found
+ */
+function getFromSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  path: string | string[],
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): T | S | undefined {
+  let fieldSchema = schema;
+  if (has(schema, REF_KEY)) {
+    fieldSchema = retrieveSchema<T, S, F>(validator, schema, rootSchema, undefined, experimental_customMergeAllOf);
+  }
+  if (isEmpty(path)) {
+    return fieldSchema;
+  }
+  const pathList = Array.isArray(path) ? path : path.split('.');
+  const [part, ...nestedPath] = pathList;
+  if (part && has(fieldSchema, part)) {
+    fieldSchema = get(fieldSchema, part) as S;
+    return getFromSchemaInternal<T, S, F>(
+      validator,
+      rootSchema,
+      fieldSchema,
+      nestedPath,
+      experimental_customMergeAllOf,
+    );
+  }
+  return undefined;
+}
+
+/** 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 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 schema - The current node within the JSON schema recursion
+ * @param path - The keys in the path to the desired field
+ * @param defaultValue - The value to return if a value is not found for the `pathList` path
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
+ * @returns - The inner schema from the `schema` for the given `path` or the `defaultValue` if not found
+ */
+export default function getFromSchema<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  path: string | string[],
+  defaultValue: T,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): T;
+export default function getFromSchema<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  path: string | string[],
+  defaultValue: S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): S;
+export default function getFromSchema<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  schema: S,
+  path: string | string[],
+  defaultValue: T | S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+): T | S {
+  const result = getFromSchemaInternal(validator, rootSchema, schema, path, experimental_customMergeAllOf);
+  if (result === undefined) {
+    return defaultValue;
+  }
+  return result;
+}

package/src/schema/index.ts

@@ -1,27 +1,29 @@
+import findFieldInSchema from './findFieldInSchema';
+import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf';
 import getDefaultFormState from './getDefaultFormState';
 import getDisplayLabel from './getDisplayLabel';
 import getClosestMatchingOption from './getClosestMatchingOption';
 import getFirstMatchingOption from './getFirstMatchingOption';
-import getMatchingOption from './getMatchingOption';
+import getFromSchema from './getFromSchema';
 import isFilesArray from './isFilesArray';
 import isMultiSelect from './isMultiSelect';
 import isSelect from './isSelect';
-import mergeValidationData from './mergeValidationData';
 import retrieveSchema from './retrieveSchema';
 import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
 import toIdSchema from './toIdSchema';
 import toPathSchema from './toPathSchema';
 
 export {
+  findFieldInSchema,
+  findSelectedOptionInXxxOf,
   getDefaultFormState,
   getDisplayLabel,
   getClosestMatchingOption,
   getFirstMatchingOption,
-  getMatchingOption,
+  getFromSchema,
   isFilesArray,
   isMultiSelect,
   isSelect,
-  mergeValidationData,
   retrieveSchema,
   sanitizeDataForNewSchema,
   toIdSchema,

package/src/schema/isFilesArray.ts

@@ -23,7 +23,7 @@ export default function isFilesArray<T = any, S extends StrictRJSFSchema = RJSFS
   schema: S,
   uiSchema: UiSchema<T, S, F> = {},
   rootSchema?: S,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
   if (uiSchema[UI_WIDGET_KEY] === 'files') {
     return true;
@@ -34,7 +34,7 @@ export default function isFilesArray<T = any, S extends StrictRJSFSchema = RJSFS
       schema.items as S,
       rootSchema,
       undefined,
-      experimental_customMergeAllOf
+      experimental_customMergeAllOf,
     );
     return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
   }

package/src/schema/isMultiSelect.ts

@@ -13,12 +13,12 @@ import isSelect from './isSelect';
 export default function isMultiSelect<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
+  F extends FormContextType = any,
 >(
   validator: ValidatorType<T, S, F>,
   schema: S,
   rootSchema?: S,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
   if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
     return false;

package/src/schema/isSelect.ts

@@ -14,7 +14,7 @@ export default function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchem
   validator: ValidatorType<T, S, F>,
   theSchema: S,
   rootSchema: S = {} as S,
-  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
   const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined, experimental_customMergeAllOf);
   const altSchemas = schema.oneOf || schema.anyOf;