@rjsf/utils 5.11.2 → 5.12.0

package/src/createSchemaUtils.ts

@@ -0,0 +1,298 @@
+import deepEquals from './deepEquals';
+import {
+  ErrorSchema,
+  Experimental_DefaultFormStateBehavior,
+  FormContextType,
+  GlobalUISchemaOptions,
+  IdSchema,
+  PathSchema,
+  RJSFSchema,
+  SchemaUtilsType,
+  StrictRJSFSchema,
+  UiSchema,
+  ValidationData,
+  ValidatorType,
+} from './types';
+import {
+  getDefaultFormState,
+  getDisplayLabel,
+  getClosestMatchingOption,
+  getFirstMatchingOption,
+  getMatchingOption,
+  isFilesArray,
+  isMultiSelect,
+  isSelect,
+  mergeValidationData,
+  retrieveSchema,
+  sanitizeDataForNewSchema,
+  toIdSchema,
+  toPathSchema,
+} 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.
+ */
+class SchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>
+  implements SchemaUtilsType<T, S, F>
+{
+  rootSchema: S;
+  validator: ValidatorType<T, S, F>;
+  experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior;
+
+  /** 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
+   */
+  constructor(
+    validator: ValidatorType<T, S, F>,
+    rootSchema: S,
+    experimental_defaultFormStateBehavior: Experimental_DefaultFormStateBehavior
+  ) {
+    this.rootSchema = rootSchema;
+    this.validator = validator;
+    this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
+  }
+
+  /** Returns the `ValidatorType` in the `SchemaUtilsType`
+   *
+   * @returns - The `ValidatorType`
+   */
+  getValidator() {
+    return this.validator;
+  }
+
+  /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
+   * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation
+   * of a new `SchemaUtilsType` with incomplete properties.
+   *
+   * @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
+   * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
+   */
+  doesSchemaUtilsDiffer(
+    validator: ValidatorType<T, S, F>,
+    rootSchema: S,
+    experimental_defaultFormStateBehavior = {}
+  ): boolean {
+    if (!validator || !rootSchema) {
+      return false;
+    }
+    return (
+      this.validator !== validator ||
+      !deepEquals(this.rootSchema, rootSchema) ||
+      !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior)
+    );
+  }
+
+  /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
+   * computed to have defaults provided in the `schema`.
+   *
+   * @param schema - The schema for which the default state is desired
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+   *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+   *          object properties.
+   * @returns - The resulting `formData` with all the defaults provided
+   */
+  getDefaultFormState(
+    schema: S,
+    formData?: T,
+    includeUndefinedValues: boolean | 'excludeObjectChildren' = false
+  ): T | T[] | undefined {
+    return getDefaultFormState<T, S, F>(
+      this.validator,
+      schema,
+      formData,
+      this.rootSchema,
+      includeUndefinedValues,
+      this.experimental_defaultFormStateBehavior
+    );
+  }
+
+  /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+   * should be displayed in a UI.
+   *
+   * @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 [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
+   */
+  getDisplayLabel(schema: S, uiSchema?: UiSchema<T, S, F>, globalOptions?: GlobalUISchemaOptions) {
+    return getDisplayLabel<T, S, F>(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
+  }
+
+  /** Determines which of the given `options` provided most closely matches the `formData`.
+   * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
+   *
+   * The closest match is determined using the number of matching properties, and more heavily favors options with
+   * matching readOnly, default, or const values.
+   *
+   * @param formData - The form data associated with the schema
+   * @param options - The list of options that can be selected from
+   * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
+   * @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 option that is the closest match to the `formData` or the `selectedOption` if no match
+   */
+  getClosestMatchingOption(
+    formData: T | undefined,
+    options: S[],
+    selectedOption?: number,
+    discriminatorField?: string
+  ): number {
+    return getClosestMatchingOption<T, S, F>(
+      this.validator,
+      this.rootSchema,
+      formData,
+      options,
+      selectedOption,
+      discriminatorField
+    );
+  }
+
+  /** 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 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 [discriminatorField] - The optional name of the field within the options object whose value is used to
+   *          determine which option is selected
+   * @returns - The firstindex of the matched option or 0 if none is available
+   */
+  getFirstMatchingOption(formData: T | undefined, options: S[], discriminatorField?: string): number {
+    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.
+   *
+   * @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
+   */
+  getMatchingOption(formData: T | undefined, options: S[], discriminatorField?: string) {
+    return getMatchingOption<T, S, F>(this.validator, formData, options, this.rootSchema, discriminatorField);
+  }
+
+  /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+   *
+   * @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
+   * @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);
+  }
+
+  /** Checks to see if the `schema` combination represents a multi-select
+   *
+   * @param schema - The schema for which check for a multi-select flag is desired
+   * @returns - True if schema contains a multi-select, otherwise false
+   */
+  isMultiSelect(schema: S) {
+    return isMultiSelect<T, S, F>(this.validator, schema, this.rootSchema);
+  }
+
+  /** Checks to see if the `schema` combination represents a select
+   *
+   * @param schema - The schema for which check for a select flag is desired
+   * @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);
+  }
+
+  /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
+   * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
+   * recursive resolution.
+   *
+   * @param schema - The schema for which retrieving a schema is desired
+   * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+   * @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);
+  }
+
+  /** 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 schemas that are non-existent in the new schema are set to `undefined`.
+   *
+   * @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.
+   */
+  sanitizeDataForNewSchema(newSchema?: S, oldSchema?: S, data?: any): T {
+    return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
+  }
+
+  /** Generates an `IdSchema` object for the `schema`, recursively
+   *
+   * @param schema - The schema for which the display label flag is desired
+   * @param [id] - The base id for the schema
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @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`
+   */
+  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);
+  }
+
+  /** Generates an `PathSchema` object for the `schema`, recursively
+   *
+   * @param schema - The schema for which the display label flag is desired
+   * @param [name] - The base name for the schema
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @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);
+  }
+}
+
+/** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
+ * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
+ *
+ * @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
+ * @returns - An implementation of a `SchemaUtilsType` interface
+ */
+export default function createSchemaUtils<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  validator: ValidatorType<T, S, F>,
+  rootSchema: S,
+  experimental_defaultFormStateBehavior = {}
+): SchemaUtilsType<T, S, F> {
+  return new SchemaUtils<T, S, F>(validator, rootSchema, experimental_defaultFormStateBehavior);
+}

package/src/dataURItoBlob.ts

@@ -0,0 +1,42 @@
+/** Given the `FileReader.readAsDataURL()` based `dataURI` extracts that data into an actual Blob along with the name
+ * of that Blob if provided in the URL. If no name is provided, then the name falls back to `unknown`.
+ *
+ * @param dataURI - The `DataUrl` potentially containing name and raw data to be converted to a Blob
+ * @returns - an object containing a Blob and its name, extracted from the URI
+ */
+export default function dataURItoBlob(dataURI: string) {
+  // Split metadata from data
+  const splitted: string[] = dataURI.split(',');
+  // Split params
+  const params: string[] = splitted[0].split(';');
+  // Get mime-type from params
+  const type: string = params[0].replace('data:', '');
+  // Filter the name property from params
+  const properties = params.filter((param) => {
+    return param.split('=')[0] === 'name';
+  });
+  // Look for the name and use unknown if no name property.
+  let name: string;
+  if (properties.length !== 1) {
+    name = 'unknown';
+  } else {
+    // Because we filtered out the other property,
+    // we only have the name case here, which we decode to make it human-readable
+    name = decodeURI(properties[0].split('=')[1]);
+  }
+
+  // Built the Uint8Array Blob parameter from the base64 string.
+  try {
+    const binary = atob(splitted[1]);
+    const array = [];
+    for (let i = 0; i < binary.length; i++) {
+      array.push(binary.charCodeAt(i));
+    }
+    // Create the blob object
+    const blob = new window.Blob([new Uint8Array(array)], { type });
+
+    return { blob, name };
+  } catch (error) {
+    return { blob: { size: 0, type: (error as Error).message }, name: dataURI };
+  }
+}

package/src/deepEquals.ts

@@ -0,0 +1,19 @@
+import isEqualWith from 'lodash/isEqualWith';
+
+/** Implements a deep equals using the `lodash.isEqualWith` function, that provides a customized comparator that
+ * assumes all functions are equivalent.
+ *
+ * @param a - The first element to compare
+ * @param b - The second element to compare
+ * @returns - True if the `a` and `b` are deeply equal, false otherwise
+ */
+export default function deepEquals(a: any, b: any): boolean {
+  return isEqualWith(a, b, (obj: any, other: any) => {
+    if (typeof obj === 'function' && typeof other === 'function') {
+      // Assume all functions are equivalent
+      // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
+      return true;
+    }
+    return undefined; // fallback to default isEquals behavior
+  });
+}

package/src/englishStringTranslator.ts

@@ -0,0 +1,14 @@
+import { TranslatableString } from './enums';
+import replaceStringParameters from './replaceStringParameters';
+
+/** Translates a `TranslatableString` value `stringToTranslate` into english. When a `params` array is provided, each
+ * value in the array is used to replace any of the replaceable parameters in the `stringToTranslate` using the `%1`,
+ * `%2`, etc. replacement specifiers.
+ *
+ * @param stringToTranslate - The `TranslatableString` value to convert to english
+ * @param params - The optional list of replaceable parameter values to substitute into the english string
+ * @returns - The `stringToTranslate` itself with any replaceable parameter values substituted
+ */
+export default function englishStringTranslator(stringToTranslate: TranslatableString, params?: string[]): string {
+  return replaceStringParameters(stringToTranslate, params);
+}

package/src/enumOptionsDeselectValue.ts

@@ -0,0 +1,28 @@
+import isEqual from 'lodash/isEqual';
+
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+
+/** 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
+ * a single value, then if the enum option value with the `valueIndex` in `allEnumOptions` matches `selected`, undefined
+ * is returned, otherwise the `selected` value is returned.
+ *
+ * @param valueIndex - The index of the value to be removed from the selected list or single value
+ * @param selected - The current (list of) selected value(s)
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @returns - The updated `selected` with the enum option value at `valueIndex` in `allEnumOptions` removed from it,
+ *        unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns
+ *        undefined, otherwise `selected`.
+ */
+export default function enumOptionsDeselectValue<S extends StrictRJSFSchema = RJSFSchema>(
+  valueIndex: string | number,
+  selected?: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
+  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 isEqual(value, selected) ? undefined : selected;
+}

package/src/enumOptionsIndexForValue.ts

@@ -0,0 +1,27 @@
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import enumOptionsIsSelected from './enumOptionsIsSelected';
+
+/** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
+ * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
+ * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is
+ * returned.
+ *
+ * @param value - The single value or list of values for which indexes are desired
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one
+ * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list
+ *        of indexes for (each of) the value(s) in `value`.
+ */
+export default function enumOptionsIndexForValue<S extends StrictRJSFSchema = RJSFSchema>(
+  value: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][],
+  allEnumOptions: EnumOptionsType<S>[] = [],
+  multiple = false
+): string | string[] | undefined {
+  const selectedIndexes: string[] = allEnumOptions
+    .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined))
+    .filter((opt) => typeof opt !== 'undefined') as string[];
+  if (!multiple) {
+    return selectedIndexes[0];
+  }
+  return selectedIndexes;
+}

package/src/enumOptionsIsSelected.ts

@@ -0,0 +1,19 @@
+import isEqual from 'lodash/isEqual';
+
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Determines whether the given `value` is (one of) the `selected` value(s).
+ *
+ * @param value - The value being checked to see if it is selected
+ * @param selected - The current selected value or list of values
+ * @returns - true if the `value` is one of the `selected` ones, false otherwise
+ */
+export default function enumOptionsIsSelected<S extends StrictRJSFSchema = RJSFSchema>(
+  value: EnumOptionsType<S>['value'],
+  selected: EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][]
+) {
+  if (Array.isArray(selected)) {
+    return selected.some((sel) => isEqual(sel, value));
+  }
+  return isEqual(selected, value);
+}

package/src/enumOptionsSelectValue.ts

@@ -0,0 +1,28 @@
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+import { isNil } from 'lodash';
+
+/** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by
+ * `allEnumOptions`
+ *
+ * @param valueIndex - The index of the value that should be selected
+ * @param selected - The current list of selected values
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @returns - The updated list of selected enum values with enum value at the `valueIndex` added to it
+ */
+export default function enumOptionsSelectValue<S extends StrictRJSFSchema = RJSFSchema>(
+  valueIndex: string | number,
+  selected: EnumOptionsType<S>['value'][],
+  allEnumOptions: EnumOptionsType<S>[] = []
+) {
+  const value = enumOptionsValueForIndex<S>(valueIndex, allEnumOptions);
+  if (!isNil(value)) {
+    const index = allEnumOptions.findIndex((opt) => value === opt.value);
+    const all = allEnumOptions.map(({ value: val }) => val);
+    const updated = selected.slice(0, index).concat(value, selected.slice(index));
+    // As inserting values at predefined index positions doesn't work with empty
+    // arrays, we need to reorder the updated selection to match the initial order
+    return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
+  }
+  return selected;
+}

package/src/enumOptionsValueForIndex.ts

@@ -0,0 +1,26 @@
+import { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an
+ * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it
+ * contains an invalid index, the returned array will have the resulting undefined values filtered out, leaving only
+ * valid values or in the worst case, an empty array.
+ *
+ * @param valueIndex - The index(es) of the value(s) that should be returned
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @param [emptyValue] - The value to return when the non-array `valueIndex` does not refer to a real option
+ * @returns - The single or list of values specified by the single or list of indexes if they are valid. Otherwise,
+ *        `emptyValue` or an empty list.
+ */
+export default function enumOptionsValueForIndex<S extends StrictRJSFSchema = RJSFSchema>(
+  valueIndex: string | number | Array<string | number>,
+  allEnumOptions: EnumOptionsType<S>[] = [],
+  emptyValue?: EnumOptionsType<S>['value']
+): EnumOptionsType<S>['value'] | EnumOptionsType<S>['value'][] | undefined {
+  if (Array.isArray(valueIndex)) {
+    return valueIndex.map((index) => enumOptionsValueForIndex(index, allEnumOptions)).filter((val) => val);
+  }
+  // So Number(null) and Number('') both return 0, so use emptyValue for those two values
+  const index = valueIndex === '' || valueIndex === null ? -1 : Number(valueIndex);
+  const option = allEnumOptions[index];
+  return option ? option.value : emptyValue;
+}

package/src/enums.ts

@@ -0,0 +1,74 @@
+/** An enumeration of all the translatable strings used by `@rjsf/core` and its themes. The value of each of the
+ * enumeration keys is expected to be the actual english string. Some strings contain replaceable parameter values
+ * as indicated by `%1`, `%2`, etc. The number after the `%` indicates the order of the parameter. The ordering of
+ * parameters is important because some languages may choose to put the second parameter before the first in its
+ * translation. Also, some strings are rendered using `markdown-to-jsx` and thus support markdown and inline html.
+ */
+export enum TranslatableString {
+  /** Fallback title of an array item, used by ArrayField */
+  ArrayItemTitle = 'Item',
+  /** Missing items reason, used by ArrayField */
+  MissingItems = 'Missing items definition',
+  /** Yes label, used by BooleanField */
+  YesLabel = 'Yes',
+  /** No label, used by BooleanField */
+  NoLabel = 'No',
+  /** Close label, used by ErrorList */
+  CloseLabel = 'Close',
+  /** Errors label, used by ErrorList */
+  ErrorsLabel = 'Errors',
+  /** New additionalProperties string default value, used by ObjectField */
+  NewStringDefault = 'New Value',
+  /** Add button title, used by AddButton */
+  AddButton = 'Add',
+  /** Add button title, used by AddButton */
+  AddItemButton = 'Add Item',
+  /** Copy button title, used by IconButton */
+  CopyButton = 'Copy',
+  /** Move down button title, used by IconButton */
+  MoveDownButton = 'Move down',
+  /** Move up button title, used by IconButton */
+  MoveUpButton = 'Move up',
+  /** Remove button title, used by IconButton */
+  RemoveButton = 'Remove',
+  /** Now label, used by AltDateWidget */
+  NowLabel = 'Now',
+  /** Clear label, used by AltDateWidget */
+  ClearLabel = 'Clear',
+  /** Aria date label, used by DateWidget */
+  AriaDateLabel = 'Select a date',
+  /** File preview label, used by FileWidget */
+  PreviewLabel = 'Preview',
+  /** Decrement button aria label, used by UpDownWidget */
+  DecrementAriaLabel = 'Decrease value by 1',
+  /** Increment button aria label, used by UpDownWidget */
+  IncrementAriaLabel = 'Increase value by 1',
+  // Strings with replaceable parameters
+  /** Unknown field type reason, where %1 will be replaced with the type as provided by SchemaField */
+  UnknownFieldType = 'Unknown field type %1',
+  /** Option prefix, where %1 will be replaced with the option index as provided by MultiSchemaField */
+  OptionPrefix = 'Option %1',
+  /** Option prefix, where %1 and %2 will be replaced by the schema title and option index, respectively as provided by
+   * MultiSchemaField
+   */
+  TitleOptionPrefix = '%1 option %2',
+  /** Key label, where %1 will be replaced by the label as provided by WrapIfAdditionalTemplate */
+  KeyLabel = '%1 Key',
+  // Strings with replaceable parameters AND/OR that support markdown and html
+  /** Invalid object field configuration as provided by the ObjectField */
+  InvalidObjectField = 'Invalid "%1" object field configuration: <em>%2</em>.',
+  /** Unsupported field schema, used by UnsupportedField */
+  UnsupportedField = 'Unsupported field schema.',
+  /** Unsupported field schema, where %1 will be replaced by the idSchema.$id as provided by UnsupportedField */
+  UnsupportedFieldWithId = 'Unsupported field schema for field <code>%1</code>.',
+  /** Unsupported field schema, where %1 will be replaced by the reason string as provided by UnsupportedField */
+  UnsupportedFieldWithReason = 'Unsupported field schema: <em>%1</em>.',
+  /** Unsupported field schema, where %1 and %2 will be replaced by the idSchema.$id and reason strings, respectively,
+   * as provided by UnsupportedField
+   */
+  UnsupportedFieldWithIdAndReason = 'Unsupported field schema for field <code>%1</code>: <em>%2</em>.',
+  /** File name, type and size info, where %1, %2 and %3 will be replaced by the file name, file type and file size as
+   * provided by FileWidget
+   */
+  FilesInfo = '<strong>%1</strong> (%2, %3 bytes)',
+}

package/src/findSchemaDefinition.ts

@@ -0,0 +1,54 @@
+import jsonpointer from 'jsonpointer';
+import omit from 'lodash/omit';
+
+import { REF_KEY } from './constants';
+import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
+
+/** 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`.
+ *
+ * @param key - The key from the object to extract
+ * @param object - The object from which to extract the element
+ * @returns - An array with the first value being the object minus the `key` element and the second element being the
+ *      value from `object[key]`
+ */
+export function splitKeyElementFromObject(key: string, object: GenericObjectType) {
+  const value = object[key];
+  const remaining = omit(object, [key]);
+  return [remaining, value];
+}
+
+/** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
+ * path provided by that reference. If `#` is not the first character of the reference, or the path does not exist in
+ * the schema, then throw an Error. Otherwise return the sub-schema. Also deals with nested `$ref`s in the sub-schema.
+ *
+ * @param $ref - The ref string for which the schema definition is desired
+ * @param [rootSchema={}] - The root schema in which to search for the definition
+ * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
+ * @throws - Error indicating that no schema for that reference exists
+ */
+export default function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>(
+  $ref?: string,
+  rootSchema: S = {} as S
+): S {
+  let ref = $ref || '';
+  if (ref.startsWith('#')) {
+    // Decode URI fragment representation.
+    ref = decodeURIComponent(ref.substring(1));
+  } else {
+    throw new Error(`Could not find a definition for ${$ref}.`);
+  }
+  const current: S = jsonpointer.get(rootSchema, ref);
+  if (current === undefined) {
+    throw new Error(`Could not find a definition for ${$ref}.`);
+  }
+  if (current[REF_KEY]) {
+    const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
+    const subSchema = findSchemaDefinition<S>(theRef, rootSchema);
+    if (Object.keys(remaining).length > 0) {
+      return { ...remaining, ...subSchema };
+    }
+    return subSchema;
+  }
+  return current;
+}

package/src/getDiscriminatorFieldFromSchema.ts

@@ -0,0 +1,21 @@
+import get from 'lodash/get';
+import isString from 'lodash/isString';
+
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** 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.
+ *
+ * @param schema - The schema from which the discriminator is potentially obtained
+ * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined`
+ */
+export default function getDiscriminatorFieldFromSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
+  let discriminator: string | undefined;
+  const maybeString = get(schema, 'discriminator.propertyName', undefined);
+  if (isString(maybeString)) {
+    discriminator = maybeString;
+  } else if (maybeString !== undefined) {
+    console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`);
+  }
+  return discriminator;
+}