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

package/src/schema/getDisplayLabel.ts

@@ -9,6 +9,7 @@ import {
   StrictRJSFSchema,
   UiSchema,
   ValidatorType,
+  Experimental_CustomMergeAllOf,
 } from '../types';
 import isFilesArray from './isFilesArray';
 import isMultiSelect from './isMultiSelect';
@@ -21,18 +22,20 @@ import isMultiSelect from './isMultiSelect';
  * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
  * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if the label should be displayed or false if it should not
  */
 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
+  globalOptions?: GlobalUISchemaOptions,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): boolean {
   const uiOptions = getUiOptions<T, S, F>(uiSchema, globalOptions);
   const { label = true } = uiOptions;
@@ -41,8 +44,8 @@ export default function getDisplayLabel<
 
   if (schemaType === 'array') {
     displayLabel =
-      isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
-      isFilesArray<T, S, F>(validator, schema, uiSchema, rootSchema) ||
+      isMultiSelect<T, S, F>(validator, schema, rootSchema, experimental_customMergeAllOf) ||
+      isFilesArray<T, S, F>(validator, schema, uiSchema, rootSchema, experimental_customMergeAllOf) ||
       isCustomWidget(uiSchema);
   }
 

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

@@ -1,5 +1,12 @@
 import { UI_WIDGET_KEY } from '../constants';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, ValidatorType } from '../types';
+import {
+  Experimental_CustomMergeAllOf,
+  FormContextType,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidatorType,
+} from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
@@ -8,19 +15,27 @@ import retrieveSchema from './retrieveSchema';
  * @param schema - The schema for which check for array of files flag is desired
  * @param [uiSchema={}] - The UI schema from which to check the widget
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema/uiSchema contains an array of files, otherwise false
  */
 export default function isFilesArray<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   schema: S,
   uiSchema: UiSchema<T, S, F> = {},
-  rootSchema?: S
+  rootSchema?: S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
   if (uiSchema[UI_WIDGET_KEY] === 'files') {
     return true;
   }
   if (schema.items) {
-    const itemsSchema = retrieveSchema<T, S, F>(validator, schema.items as S, rootSchema);
+    const itemsSchema = retrieveSchema<T, S, F>(
+      validator,
+      schema.items as S,
+      rootSchema,
+      undefined,
+      experimental_customMergeAllOf,
+    );
     return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
   }
   return false;

package/src/schema/isMultiSelect.ts

@@ -1,4 +1,4 @@
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
 
 import isSelect from './isSelect';
 
@@ -7,15 +7,21 @@ import isSelect from './isSelect';
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param schema - The schema for which check for a multi-select flag is desired
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema contains a multi-select, otherwise false
  */
 export default function isMultiSelect<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any
->(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S) {
+  F extends FormContextType = any,
+>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  rootSchema?: S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
+) {
   if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
     return false;
   }
-  return isSelect<T, S, F>(validator, schema.items as S, rootSchema);
+  return isSelect<T, S, F>(validator, schema.items as S, rootSchema, experimental_customMergeAllOf);
 }

package/src/schema/isSelect.ts

@@ -1,5 +1,5 @@
 import isConstant from '../isConstant';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType, Experimental_CustomMergeAllOf } from '../types';
 import retrieveSchema from './retrieveSchema';
 
 /** Checks to see if the `schema` combination represents a select
@@ -7,14 +7,16 @@ import retrieveSchema from './retrieveSchema';
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
  * @param theSchema - The schema for which check for a select flag is desired
  * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
  * @returns - True if schema contains a select, otherwise false
  */
 export default function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
   validator: ValidatorType<T, S, F>,
   theSchema: S,
-  rootSchema: S = {} as S
+  rootSchema: S = {} as S,
+  experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ) {
-  const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined);
+  const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined, experimental_customMergeAllOf);
   const altSchemas = schema.oneOf || schema.anyOf;
   if (Array.isArray(schema.enum)) {
     return true;