@rjsf/utils 5.11.2 → 5.12.0

package/src/getInputProps.ts

@@ -0,0 +1,55 @@
+import rangeSpec from './rangeSpec';
+import { FormContextType, InputPropsType, RJSFSchema, StrictRJSFSchema, UIOptionsType } from './types';
+
+/** Using the `schema`, `defaultType` and `options`, extract out the props for the <input> element that make sense.
+ *
+ * @param schema - The schema for the field provided by the widget
+ * @param [defaultType] - The default type, if any, for the field provided by the widget
+ * @param [options={}] - The UI Options for the field provided by the widget
+ * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step
+ * @returns - The extracted `InputPropsType` object
+ */
+export default function getInputProps<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(
+  schema: RJSFSchema,
+  defaultType?: string,
+  options: UIOptionsType<T, S, F> = {},
+  autoDefaultStepAny = true
+): InputPropsType {
+  const inputProps: InputPropsType = {
+    type: defaultType || 'text',
+    ...rangeSpec(schema),
+  };
+
+  // If options.inputType is set use that as the input type
+  if (options.inputType) {
+    inputProps.type = options.inputType;
+  } else if (!defaultType) {
+    // If the schema is of type number or integer, set the input type to number
+    if (schema.type === 'number') {
+      inputProps.type = 'number';
+      // Only add step if one isn't already defined and we are auto-defaulting the "any" step
+      if (autoDefaultStepAny && inputProps.step === undefined) {
+        // Setting step to 'any' fixes a bug in Safari where decimals are not
+        // allowed in number inputs
+        inputProps.step = 'any';
+      }
+    } else if (schema.type === 'integer') {
+      inputProps.type = 'number';
+      // Only add step if one isn't already defined
+      if (inputProps.step === undefined) {
+        // Since this is integer, you always want to step up or down in multiples of 1
+        inputProps.step = 1;
+      }
+    }
+  }
+
+  if (options.autocomplete) {
+    inputProps.autoComplete = options.autocomplete;
+  }
+
+  return inputProps;
+}

package/src/getSchemaType.ts

@@ -0,0 +1,37 @@
+import guessType from './guessType';
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Gets the type of a given `schema`. If the type is not explicitly defined, then an attempt is made to infer it from
+ * other elements of the schema as follows:
+ * - schema.const: Returns the `guessType()` of that value
+ * - schema.enum: Returns `string`
+ * - schema.properties: Returns `object`
+ * - schema.additionalProperties: Returns `object`
+ * - type is an array with a length of 2 and one type is 'null': Returns the other type
+ *
+ * @param schema - The schema for which to get the type
+ * @returns - The type of the schema
+ */
+export default function getSchemaType<S extends StrictRJSFSchema = RJSFSchema>(
+  schema: S
+): string | string[] | undefined {
+  let { type } = schema;
+
+  if (!type && schema.const) {
+    return guessType(schema.const);
+  }
+
+  if (!type && schema.enum) {
+    return 'string';
+  }
+
+  if (!type && (schema.properties || schema.additionalProperties)) {
+    return 'object';
+  }
+
+  if (Array.isArray(type) && type.length === 2 && type.includes('null')) {
+    type = type.find((type) => type !== 'null');
+  }
+
+  return type;
+}

package/src/getSubmitButtonOptions.ts

@@ -0,0 +1,32 @@
+import { SUBMIT_BTN_OPTIONS_KEY } from './constants';
+import getUiOptions from './getUiOptions';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, UISchemaSubmitButtonOptions } from './types';
+
+/** The default submit button options, exported for testing purposes
+ */
+export const DEFAULT_OPTIONS: UISchemaSubmitButtonOptions = {
+  props: {
+    disabled: false,
+  },
+  submitText: 'Submit',
+  norender: false,
+};
+
+/** Extracts any `ui:submitButtonOptions` from the `uiSchema` and merges them onto the `DEFAULT_OPTIONS`
+ *
+ * @param [uiSchema={}] - the UI Schema from which to extract submit button props
+ * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones
+ */
+export default function getSubmitButtonOptions<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(uiSchema: UiSchema<T, S, F> = {}): UISchemaSubmitButtonOptions {
+  const uiOptions = getUiOptions<T, S, F>(uiSchema);
+  if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
+    const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY] as UISchemaSubmitButtonOptions;
+    return { ...DEFAULT_OPTIONS, ...options };
+  }
+
+  return DEFAULT_OPTIONS;
+}

package/src/getTemplate.ts

@@ -0,0 +1,26 @@
+import { FormContextType, TemplatesType, Registry, UIOptionsType, StrictRJSFSchema, RJSFSchema } from './types';
+
+/** Returns the template with the given `name` from either the `uiSchema` if it is defined or from the `registry`
+ * otherwise. NOTE, since `ButtonTemplates` are not overridden in `uiSchema` only those in the `registry` are returned.
+ *
+ * @param name - The name of the template to fetch, restricted to the keys of `TemplatesType`
+ * @param registry - The `Registry` from which to read the template
+ * @param [uiOptions={}] - The `UIOptionsType` from which to read an alternate template
+ * @returns - The template from either the `uiSchema` or `registry` for the `name`
+ */
+export default function getTemplate<
+  Name extends keyof TemplatesType<T, S, F>,
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(name: Name, registry: Registry<T, S, F>, uiOptions: UIOptionsType<T, S, F> = {}): TemplatesType<T, S, F>[Name] {
+  const { templates } = registry;
+  if (name === 'ButtonTemplates') {
+    return templates[name];
+  }
+  return (
+    // Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent
+    // To avoid that, we cast uiOptions to `any` before accessing the name field
+    ((uiOptions as any)[name] as TemplatesType<T, S, F>[Name]) || templates[name]
+  );
+}

package/src/getUiOptions.ts

@@ -0,0 +1,32 @@
+import { UI_OPTIONS_KEY, UI_WIDGET_KEY } from './constants';
+import isObject from './isObject';
+import { FormContextType, GlobalUISchemaOptions, RJSFSchema, StrictRJSFSchema, UIOptionsType, UiSchema } from './types';
+
+/** Get all passed options from ui:options, and ui:<optionName>, returning them in an object with the `ui:`
+ * stripped off. Any `globalOptions` will always be returned, unless they are overridden by options in the `uiSchema`.
+ *
+ * @param [uiSchema={}] - The UI Schema from which to get any `ui:xxx` options
+ * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
+ * @returns - An object containing all the `ui:xxx` options with the `ui:` stripped off along with all `globalOptions`
+ */
+export default function getUiOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  uiSchema: UiSchema<T, S, F> = {},
+  globalOptions: GlobalUISchemaOptions = {}
+): UIOptionsType<T, S, F> {
+  return Object.keys(uiSchema)
+    .filter((key) => key.indexOf('ui:') === 0)
+    .reduce(
+      (options, key) => {
+        const value = uiSchema[key];
+        if (key === UI_WIDGET_KEY && isObject(value)) {
+          console.error('Setting options via ui:widget object is no longer supported, use ui:options instead');
+          return options;
+        }
+        if (key === UI_OPTIONS_KEY && isObject(value)) {
+          return { ...options, ...value };
+        }
+        return { ...options, [key.substring(3)]: value };
+      },
+      { ...globalOptions }
+    );
+}

package/src/getWidget.tsx

@@ -0,0 +1,133 @@
+import { createElement } from 'react';
+import ReactIs from 'react-is';
+import get from 'lodash/get';
+import set from 'lodash/set';
+
+import { FormContextType, RJSFSchema, Widget, RegistryWidgetsType, StrictRJSFSchema } from './types';
+import getSchemaType from './getSchemaType';
+
+/** The map of schema types to widget type to widget name
+ */
+const widgetMap: { [k: string]: { [j: string]: string } } = {
+  boolean: {
+    checkbox: 'CheckboxWidget',
+    radio: 'RadioWidget',
+    select: 'SelectWidget',
+    hidden: 'HiddenWidget',
+  },
+  string: {
+    text: 'TextWidget',
+    password: 'PasswordWidget',
+    email: 'EmailWidget',
+    hostname: 'TextWidget',
+    ipv4: 'TextWidget',
+    ipv6: 'TextWidget',
+    uri: 'URLWidget',
+    'data-url': 'FileWidget',
+    radio: 'RadioWidget',
+    select: 'SelectWidget',
+    textarea: 'TextareaWidget',
+    hidden: 'HiddenWidget',
+    date: 'DateWidget',
+    datetime: 'DateTimeWidget',
+    'date-time': 'DateTimeWidget',
+    'alt-date': 'AltDateWidget',
+    'alt-datetime': 'AltDateTimeWidget',
+    time: 'TimeWidget',
+    color: 'ColorWidget',
+    file: 'FileWidget',
+  },
+  number: {
+    text: 'TextWidget',
+    select: 'SelectWidget',
+    updown: 'UpDownWidget',
+    range: 'RangeWidget',
+    radio: 'RadioWidget',
+    hidden: 'HiddenWidget',
+  },
+  integer: {
+    text: 'TextWidget',
+    select: 'SelectWidget',
+    updown: 'UpDownWidget',
+    range: 'RangeWidget',
+    radio: 'RadioWidget',
+    hidden: 'HiddenWidget',
+  },
+  array: {
+    select: 'SelectWidget',
+    checkboxes: 'CheckboxesWidget',
+    files: 'FileWidget',
+    hidden: 'HiddenWidget',
+  },
+};
+
+/** Wraps the given widget with stateless functional component that will merge any `defaultProps.options` with the
+ * `options` that are provided in the props. It will add the wrapper component as a `MergedWidget` property onto the
+ * `Widget` so that future attempts to wrap `AWidget` will return the already existing wrapper.
+ *
+ * @param AWidget - A widget that will be wrapped or one that is already wrapped
+ * @returns - The wrapper widget
+ */
+function mergeWidgetOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  AWidget: Widget<T, S, F>
+) {
+  let MergedWidget: Widget<T, S, F> | undefined = get(AWidget, 'MergedWidget');
+  // cache return value as property of widget for proper react reconciliation
+  if (!MergedWidget) {
+    const defaultOptions = (AWidget.defaultProps && AWidget.defaultProps.options) || {};
+    MergedWidget = ({ options, ...props }) => {
+      return <AWidget options={{ ...defaultOptions, ...options }} {...props} />;
+    };
+    set(AWidget, 'MergedWidget', MergedWidget);
+  }
+  return MergedWidget;
+}
+
+/** Given a schema representing a field to render and either the name or actual `Widget` implementation, returns the
+ * React component that is used to render the widget. If the `widget` is already a React component, then it is wrapped
+ * with a `MergedWidget`. Otherwise an attempt is made to look up the widget inside of the `registeredWidgets` map based
+ * on the schema type and `widget` name. If no widget component can be found an `Error` is thrown.
+ *
+ * @param schema - The schema for the field
+ * @param [widget] - Either the name of the widget OR a `Widget` implementation to use
+ * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
+ * @returns - The `Widget` component to use
+ * @throws - An error if there is no `Widget` component that can be returned
+ */
+export default function getWidget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  schema: RJSFSchema,
+  widget?: Widget<T, S, F> | string,
+  registeredWidgets: RegistryWidgetsType<T, S, F> = {}
+): Widget<T, S, F> {
+  const type = getSchemaType(schema);
+
+  if (
+    typeof widget === 'function' ||
+    (widget && ReactIs.isForwardRef(createElement(widget))) ||
+    ReactIs.isMemo(widget)
+  ) {
+    return mergeWidgetOptions<T, S, F>(widget as Widget<T, S, F>);
+  }
+
+  if (typeof widget !== 'string') {
+    throw new Error(`Unsupported widget definition: ${typeof widget}`);
+  }
+
+  if (widget in registeredWidgets) {
+    const registeredWidget = registeredWidgets[widget];
+    return getWidget<T, S, F>(schema, registeredWidget, registeredWidgets);
+  }
+
+  if (typeof type === 'string') {
+    if (!(type in widgetMap)) {
+      throw new Error(`No widget for type '${type}'`);
+    }
+
+    if (widget in widgetMap[type]) {
+      const registeredWidget = registeredWidgets[widgetMap[type][widget]];
+      return getWidget<T, S, F>(schema, registeredWidget, registeredWidgets);
+    }
+  }
+
+  throw new Error(`No widget '${widget}' for type '${type}'`);
+}

package/src/guessType.ts

@@ -0,0 +1,28 @@
+/** Given a specific `value` attempts to guess the type of a schema element. In the case where we have to implicitly
+ *  create a schema, it is useful to know what type to use based on the data we are defining.
+ *
+ * @param value - The value from which to guess the type
+ * @returns - The best guess for the object type
+ */
+export default function guessType(value: any) {
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+  if (typeof value === 'string') {
+    return 'string';
+  }
+  if (value == null) {
+    return 'null';
+  }
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+  if (!isNaN(value)) {
+    return 'number';
+  }
+  if (typeof value === 'object') {
+    return 'object';
+  }
+  // Default to string if we can't figure it out
+  return 'string';
+}

package/src/hasWidget.ts

@@ -0,0 +1,27 @@
+import getWidget from './getWidget';
+import { FormContextType, RegistryWidgetsType, RJSFSchema, StrictRJSFSchema, Widget } from './types';
+
+/** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it
+ * does, or false if it doesn't.
+ *
+ * @param schema - The schema for the field
+ * @param widget - Either the name of the widget OR a `Widget` implementation to use
+ * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
+ * @returns - True if the widget exists, false otherwise
+ */
+export default function hasWidget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(
+  schema: RJSFSchema,
+  widget: Widget<T, S, F> | string,
+  registeredWidgets: RegistryWidgetsType<T, S, F> = {}
+) {
+  try {
+    getWidget(schema, widget, registeredWidgets);
+    return true;
+  } catch (e) {
+    const err: Error = e as Error;
+    if (err.message && (err.message.startsWith('No widget') || err.message.startsWith('Unsupported widget'))) {
+      return false;
+    }
+    throw e;
+  }
+}

package/src/hashForSchema.ts

@@ -0,0 +1,31 @@
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** JS has no built-in hashing function, so rolling our own
+ *  based on Java's hashing fn:
+ *  http://www.java2s.com/example/nodejs-utility-method/string-hash/hashcode-4dc2b.html
+ *
+ * @param string - The string for which to get the hash
+ * @returns - The resulting hash of the string in hex format
+ */
+function hashString(string: string): string {
+  let hash = 0;
+  for (let i = 0; i < string.length; i += 1) {
+    const chr = string.charCodeAt(i);
+    hash = (hash << 5) - hash + chr;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return hash.toString(16);
+}
+
+/** Stringifies the schema and returns the hash of the resulting string. Sorts schema fields
+ * in consistent order before stringify to prevent different hash ids for the same schema.
+ *
+ * @param schema - The schema for which the hash is desired
+ * @returns - The string obtained from the hash of the stringified schema
+ */
+export default function hashForSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
+  const allKeys = new Set<string>();
+  // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328
+  JSON.stringify(schema, (key, value) => (allKeys.add(key), value));
+  return hashString(JSON.stringify(schema, Array.from(allKeys).sort()));
+}

package/src/idGenerators.ts

@@ -0,0 +1,81 @@
+import isString from 'lodash/isString';
+
+import { IdSchema } from './types';
+import { ID_KEY } from './constants';
+
+/** Generates a consistent `id` pattern for a given `id` and a `suffix`
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param suffix - The suffix to append to the id
+ */
+function idGenerator<T = any>(id: IdSchema<T> | string, suffix: string) {
+  const theId = isString(id) ? id : id[ID_KEY];
+  return `${theId}__${suffix}`;
+}
+/** Return a consistent `id` for the field description element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field description element from the given `id`
+ */
+export function descriptionId<T = any>(id: IdSchema<T> | string) {
+  return idGenerator<T>(id, 'description');
+}
+
+/** Return a consistent `id` for the field error element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field error element from the given `id`
+ */
+export function errorId<T = any>(id: IdSchema<T> | string) {
+  return idGenerator<T>(id, 'error');
+}
+
+/** Return a consistent `id` for the field examples element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field examples element from the given `id`
+ */
+export function examplesId<T = any>(id: IdSchema<T> | string) {
+  return idGenerator<T>(id, 'examples');
+}
+
+/** Return a consistent `id` for the field help element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field help element from the given `id`
+ */
+export function helpId<T = any>(id: IdSchema<T> | string) {
+  return idGenerator<T>(id, 'help');
+}
+
+/** Return a consistent `id` for the field title element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field title element from the given `id`
+ */
+export function titleId<T = any>(id: IdSchema<T> | string) {
+  return idGenerator<T>(id, 'title');
+}
+
+/** Return a list of element ids that contain additional information about the field that can be used to as the aria
+ * description of the field. This is correctly omitting `titleId` which would be "labeling" rather than "describing" the
+ * element.
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list
+ * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute
+ */
+export function ariaDescribedByIds<T = any>(id: IdSchema<T> | string, includeExamples = false) {
+  const examples = includeExamples ? ` ${examplesId<T>(id)}` : '';
+  return `${errorId<T>(id)} ${descriptionId<T>(id)} ${helpId<T>(id)}${examples}`;
+}
+
+/** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget
+ *
+ * @param id - The id of the parent component for the option
+ * @param optionIndex - The index of the option for which the id is desired
+ * @returns - An id for the option index based on the parent `id`
+ */
+export function optionId(id: string, optionIndex: number) {
+  return `${id}-${optionIndex}`;
+}

package/src/index.ts

@@ -0,0 +1,118 @@
+import allowAdditionalItems from './allowAdditionalItems';
+import asNumber from './asNumber';
+import canExpand from './canExpand';
+import createErrorHandler from './createErrorHandler';
+import createSchemaUtils from './createSchemaUtils';
+import dataURItoBlob from './dataURItoBlob';
+import deepEquals from './deepEquals';
+import englishStringTranslator from './englishStringTranslator';
+import enumOptionsDeselectValue from './enumOptionsDeselectValue';
+import enumOptionsIndexForValue from './enumOptionsIndexForValue';
+import enumOptionsIsSelected from './enumOptionsIsSelected';
+import enumOptionsSelectValue from './enumOptionsSelectValue';
+import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+import ErrorSchemaBuilder from './ErrorSchemaBuilder';
+import findSchemaDefinition from './findSchemaDefinition';
+import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
+import getInputProps from './getInputProps';
+import getSchemaType from './getSchemaType';
+import getSubmitButtonOptions from './getSubmitButtonOptions';
+import getTemplate from './getTemplate';
+import getUiOptions from './getUiOptions';
+import getWidget from './getWidget';
+import guessType from './guessType';
+import hashForSchema from './hashForSchema';
+import hasWidget from './hasWidget';
+import { ariaDescribedByIds, descriptionId, errorId, examplesId, helpId, optionId, titleId } from './idGenerators';
+import isConstant from './isConstant';
+import isCustomWidget from './isCustomWidget';
+import isFixedItems from './isFixedItems';
+import isObject from './isObject';
+import labelValue from './labelValue';
+import localToUTC from './localToUTC';
+import mergeDefaultsWithFormData from './mergeDefaultsWithFormData';
+import mergeObjects from './mergeObjects';
+import mergeSchemas from './mergeSchemas';
+import optionsList from './optionsList';
+import orderProperties from './orderProperties';
+import pad from './pad';
+import parseDateString from './parseDateString';
+import rangeSpec from './rangeSpec';
+import replaceStringParameters from './replaceStringParameters';
+import schemaRequiresTrueValue from './schemaRequiresTrueValue';
+import shouldRender from './shouldRender';
+import toConstant from './toConstant';
+import toDateString from './toDateString';
+import toErrorList from './toErrorList';
+import toErrorSchema from './toErrorSchema';
+import unwrapErrorHandler from './unwrapErrorHandler';
+import utcToLocal from './utcToLocal';
+import validationDataMerge from './validationDataMerge';
+import withIdRefPrefix from './withIdRefPrefix';
+
+export * from './types';
+export * from './enums';
+
+export * from './constants';
+export * from './parser';
+export * from './schema';
+
+export {
+  allowAdditionalItems,
+  ariaDescribedByIds,
+  asNumber,
+  canExpand,
+  createErrorHandler,
+  createSchemaUtils,
+  dataURItoBlob,
+  deepEquals,
+  descriptionId,
+  englishStringTranslator,
+  enumOptionsDeselectValue,
+  enumOptionsIndexForValue,
+  enumOptionsIsSelected,
+  enumOptionsSelectValue,
+  enumOptionsValueForIndex,
+  errorId,
+  examplesId,
+  ErrorSchemaBuilder,
+  findSchemaDefinition,
+  getDiscriminatorFieldFromSchema,
+  getInputProps,
+  getSchemaType,
+  getSubmitButtonOptions,
+  getTemplate,
+  getUiOptions,
+  getWidget,
+  guessType,
+  hasWidget,
+  hashForSchema,
+  helpId,
+  isConstant,
+  isCustomWidget,
+  isFixedItems,
+  isObject,
+  labelValue,
+  localToUTC,
+  mergeDefaultsWithFormData,
+  mergeObjects,
+  mergeSchemas,
+  optionId,
+  optionsList,
+  orderProperties,
+  pad,
+  parseDateString,
+  rangeSpec,
+  replaceStringParameters,
+  schemaRequiresTrueValue,
+  shouldRender,
+  titleId,
+  toConstant,
+  toDateString,
+  toErrorList,
+  toErrorSchema,
+  unwrapErrorHandler,
+  utcToLocal,
+  validationDataMerge,
+  withIdRefPrefix,
+};

package/src/isConstant.ts

@@ -0,0 +1,12 @@
+import { CONST_KEY } from './constants';
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** This function checks if the given `schema` matches a single constant value. This happens when either the schema has
+ * an `enum` array with a single value or there is a `const` defined.
+ *
+ * @param schema - The schema for a field
+ * @returns - True if the `schema` has a single constant value, false otherwise
+ */
+export default function isConstant<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
+  return (Array.isArray(schema.enum) && schema.enum.length === 1) || CONST_KEY in schema;
+}

package/src/isCustomWidget.ts

@@ -0,0 +1,19 @@
+import getUiOptions from './getUiOptions';
+import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+
+/** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden`
+ *
+ * @param uiSchema - The UI Schema from which to detect if it is customized
+ * @returns - True if the `uiSchema` describes a custom widget, false otherwise
+ */
+export default function isCustomWidget<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any
+>(uiSchema: UiSchema<T, S, F> = {}) {
+  return (
+    // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
+    // https://rjsf-team.github.io/react-jsonschema-form/docs/usage/widgets/#hidden-widgets
+    'widget' in getUiOptions<T, S, F>(uiSchema) && getUiOptions<T, S, F>(uiSchema)['widget'] !== 'hidden'
+  );
+}

package/src/isFixedItems.ts

@@ -0,0 +1,12 @@
+import isObject from './isObject';
+import { RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
+ * that only contains objects.
+ *
+ * @param schema - The schema in which to check for fixed items
+ * @returns - True if there are fixed items in the schema, false otherwise
+ */
+export default function isFixedItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S) {
+  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
+}

package/src/isObject.ts

@@ -0,0 +1,15 @@
+/** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has
+ * the type `object` but is NOT null, an array or a File.
+ *
+ * @param thing - The thing to check to see whether it is an object
+ * @returns - True if it is a non-null, non-array, non-File object
+ */
+export default function isObject(thing: any) {
+  if (typeof File !== 'undefined' && thing instanceof File) {
+    return false;
+  }
+  if (typeof Date !== 'undefined' && thing instanceof Date) {
+    return false;
+  }
+  return typeof thing === 'object' && thing !== null && !Array.isArray(thing);
+}