@rjsf/utils 5.11.2 → 5.12.0

package/src/schema/getDisplayLabel.ts

@@ -0,0 +1,59 @@
+import { UI_FIELD_KEY, UI_WIDGET_KEY } from '../constants';
+import getSchemaType from '../getSchemaType';
+import getUiOptions from '../getUiOptions';
+import isCustomWidget from '../isCustomWidget';
+import {
+  FormContextType,
+  GlobalUISchemaOptions,
+  RJSFSchema,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidatorType,
+} from '../types';
+import isFilesArray from './isFilesArray';
+import isMultiSelect from './isMultiSelect';
+
+/** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+ * should be displayed in a UI.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the display label flag is desired
+ * @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
+ * @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
+>(
+  validator: ValidatorType<T, S, F>,
+  schema: S,
+  uiSchema: UiSchema<T, S, F> = {},
+  rootSchema?: S,
+  globalOptions?: GlobalUISchemaOptions
+): boolean {
+  const uiOptions = getUiOptions<T, S, F>(uiSchema, globalOptions);
+  const { label = true } = uiOptions;
+  let displayLabel = !!label;
+  const schemaType = getSchemaType<S>(schema);
+
+  if (schemaType === 'array') {
+    displayLabel =
+      isMultiSelect<T, S, F>(validator, schema, rootSchema) ||
+      isFilesArray<T, S, F>(validator, schema, uiSchema, rootSchema) ||
+      isCustomWidget(uiSchema);
+  }
+
+  if (schemaType === 'object') {
+    displayLabel = false;
+  }
+  if (schemaType === 'boolean' && !uiSchema[UI_WIDGET_KEY]) {
+    displayLabel = false;
+  }
+  if (uiSchema[UI_FIELD_KEY]) {
+    displayLabel = false;
+  }
+  return displayLabel;
+}

package/src/schema/getFirstMatchingOption.ts

@@ -0,0 +1,27 @@
+import getMatchingOption from './getMatchingOption';
+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.
+ * Always returns the first option if there is nothing that matches.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param formData - The current formData, if any, used to figure out a match
+ * @param options - The list of options to find a matching options from
+ * @param rootSchema - The root schema, used to primarily to look up `$ref`s
+ * @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 first matched option or 0 if none is available
+ */
+export default function getFirstMatchingOption<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  formData: T | undefined,
+  options: S[],
+  rootSchema: S,
+  discriminatorField?: string
+): number {
+  return getMatchingOption<T, S, F>(validator, formData, options, rootSchema, discriminatorField);
+}

package/src/schema/getMatchingOption.ts

@@ -0,0 +1,95 @@
+import get from 'lodash/get';
+import has from 'lodash/has';
+
+import { PROPERTIES_KEY } from '../constants';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+
+/** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+ * Deprecated, use `getFirstMatchingOption()` instead.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param formData - The current formData, if any, used to figure out a match
+ * @param options - The list of options to find a matching options from
+ * @param rootSchema - The root schema, used to primarily to look up `$ref`s
+ * @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
+ */
+export default function getMatchingOption<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  formData: T | undefined,
+  options: S[],
+  rootSchema: S,
+  discriminatorField?: string
+): number {
+  // 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;
+  }
+  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 = get(option, [PROPERTIES_KEY, discriminatorField], {});
+      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/index.ts

@@ -0,0 +1,29 @@
+import getDefaultFormState from './getDefaultFormState';
+import getDisplayLabel from './getDisplayLabel';
+import getClosestMatchingOption from './getClosestMatchingOption';
+import getFirstMatchingOption from './getFirstMatchingOption';
+import getMatchingOption from './getMatchingOption';
+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 {
+  getDefaultFormState,
+  getDisplayLabel,
+  getClosestMatchingOption,
+  getFirstMatchingOption,
+  getMatchingOption,
+  isFilesArray,
+  isMultiSelect,
+  isSelect,
+  mergeValidationData,
+  retrieveSchema,
+  sanitizeDataForNewSchema,
+  toIdSchema,
+  toPathSchema,
+};

package/src/schema/isFilesArray.ts

@@ -0,0 +1,27 @@
+import { UI_WIDGET_KEY } from '../constants';
+import { 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
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @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
+ * @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
+) {
+  if (uiSchema[UI_WIDGET_KEY] === 'files') {
+    return true;
+  }
+  if (schema.items) {
+    const itemsSchema = retrieveSchema<T, S, F>(validator, schema.items as S, rootSchema);
+    return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
+  }
+  return false;
+}

package/src/schema/isMultiSelect.ts

@@ -0,0 +1,21 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+
+import isSelect from './isSelect';
+
+/** Checks to see if the `schema` combination represents a multi-select
+ *
+ * @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
+ * @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) {
+  if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
+    return false;
+  }
+  return isSelect<T, S, F>(validator, schema.items as S, rootSchema);
+}

package/src/schema/isSelect.ts

@@ -0,0 +1,26 @@
+import isConstant from '../isConstant';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import retrieveSchema from './retrieveSchema';
+
+/** Checks to see if the `schema` combination represents a select
+ *
+ * @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
+ * @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
+) {
+  const schema = retrieveSchema<T, S, F>(validator, theSchema, rootSchema, undefined);
+  const altSchemas = schema.oneOf || schema.anyOf;
+  if (Array.isArray(schema.enum)) {
+    return true;
+  }
+  if (Array.isArray(altSchemas)) {
+    return altSchemas.every((altSchemas) => typeof altSchemas !== 'boolean' && isConstant(altSchemas));
+  }
+  return false;
+}

package/src/schema/mergeValidationData.ts

@@ -0,0 +1,38 @@
+import isEmpty from 'lodash/isEmpty';
+
+import mergeObjects from '../mergeObjects';
+import { ErrorSchema, FormContextType, RJSFSchema, StrictRJSFSchema, ValidationData, ValidatorType } from '../types';
+
+/** 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
+ * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+ * `validationData` is returned.
+ *
+ * @param validator - The validator used to convert an ErrorSchema to a list of errors
+ * @param validationData - The current `ValidationData` into which to merge the additional errors
+ * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
+ * @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.
+ */
+export default function mergeValidationData<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  validationData: ValidationData<T>,
+  additionalErrorSchema?: ErrorSchema<T>
+): ValidationData<T> {
+  if (!additionalErrorSchema) {
+    return validationData;
+  }
+  const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
+  let errors = validator.toErrorList(additionalErrorSchema);
+  let errorSchema = additionalErrorSchema;
+  if (!isEmpty(oldErrorSchema)) {
+    errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true) as ErrorSchema<T>;
+    errors = [...oldErrors].concat(errors);
+  }
+  return { errorSchema, errors };
+}