@rjsf/utils 6.6.1 → 6.7.0

package/src/getOptionMatchingSimpleDiscriminator.ts

@@ -1,7 +1,7 @@
 import get from 'lodash/get';
 
 import { PROPERTIES_KEY } from './constants';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Compares the value of `discriminatorField` within `formData` against the value of `discriminatorField` within schema for each `option`.
  * Returns index of first `option` whose discriminator matches formData. Returns `undefined` if there is no match.
@@ -22,26 +22,22 @@ export default function getOptionMatchingSimpleDiscriminator<T = any, S extends
     const value = get(formData, discriminatorField);
 
     if (value === undefined) {
-      return;
+      return undefined;
     }
 
-    for (let i = 0; i < options.length; i++) {
+    for (let i = 0; i < options.length; i += 1) {
       const option = options[i];
       const discriminator: S = get(option, [PROPERTIES_KEY, discriminatorField], {}) as S;
 
-      if (discriminator.type === 'object' || discriminator.type === 'array') {
-        continue;
-      }
-
-      if (discriminator.const === value) {
-        return i;
-      }
-
-      if (discriminator.enum?.includes(value)) {
-        return i;
+      if (discriminator.type !== 'object' && discriminator.type !== 'array') {
+        if (discriminator.const === value) {
+          return i;
+        }
+        if (discriminator.enum?.includes(value)) {
+          return i;
+        }
       }
     }
   }
-
-  return;
+  return undefined;
 }

package/src/getOptionValueFormat.ts

@@ -1,4 +1,4 @@
-import { OptionValueFormat } from './types';
+import type { OptionValueFormat } from './types';
 
 /** Resolves the effective `optionValueFormat` for enum-backed widgets.
  *

package/src/getSchemaType.ts

@@ -1,5 +1,5 @@
 import guessType from './guessType';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { 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:
@@ -32,8 +32,9 @@ export default function getSchemaType<S extends StrictRJSFSchema = RJSFSchema>(
 
   if (Array.isArray(type)) {
     if (type.length === 2 && type.includes('null')) {
-      type = type.find((type) => type !== 'null');
+      type = type.find((t) => t !== 'null');
     } else {
+      // oxlint-disable-next-line prefer-destructuring
       type = type[0];
     }
   }

package/src/getSubmitButtonOptions.ts

@@ -1,6 +1,6 @@
 import { SUBMIT_BTN_OPTIONS_KEY } from './constants';
 import getUiOptions from './getUiOptions';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, UISchemaSubmitButtonOptions } from './types';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, UISchemaSubmitButtonOptions } from './types';
 
 /** The default submit button options, exported for testing purposes
  */
@@ -23,8 +23,8 @@ export default function getSubmitButtonOptions<
   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;
+  if (uiOptions?.[SUBMIT_BTN_OPTIONS_KEY]) {
+    const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
     return { ...DEFAULT_OPTIONS, ...options };
   }
 

package/src/getTemplate.ts

@@ -1,4 +1,4 @@
-import { FormContextType, TemplatesType, Registry, UIOptionsType, StrictRJSFSchema, RJSFSchema } from './types';
+import type { 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.

package/src/getTestIds.ts

@@ -1,7 +1,7 @@
 import get from 'lodash/get';
 import uniqueId from 'lodash/uniqueId';
 
-import { TestIdShape } from './types';
+import type { TestIdShape } from './types';
 
 /** Returns an object of test IDs that can only be used in test mode. If the function is called in a test environment
  * (`NODE_ENV === 'test'`, this is set by vitest) then a Proxy object will be returned. If a key within the returned

package/src/getUiOptions.ts

@@ -1,6 +1,13 @@
 import { UI_OPTIONS_KEY, UI_WIDGET_KEY } from './constants';
 import isObject from './isObject';
-import { FormContextType, GlobalUISchemaOptions, RJSFSchema, StrictRJSFSchema, UIOptionsType, UiSchema } from './types';
+import type {
+  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`.
@@ -18,11 +25,12 @@ export default function getUiOptions<T = any, S extends StrictRJSFSchema = RJSFS
     return { ...globalOptions };
   }
   return Object.keys(uiSchema)
-    .filter((key) => key.indexOf('ui:') === 0)
+    .filter((key) => key.startsWith('ui:'))
     .reduce(
       (options, key) => {
         const value = uiSchema[key];
         if (key === UI_WIDGET_KEY && isObject(value)) {
+          // oxlint-disable-next-line no-console
           console.error('Setting options via ui:widget object is no longer supported, use ui:options instead');
           return options;
         }

package/src/getWidget.tsx

@@ -4,11 +4,11 @@ import set from 'lodash/set';
 import ReactIs from 'react-is';
 
 import getSchemaType from './getSchemaType';
-import { FormContextType, RJSFSchema, Widget, RegistryWidgetsType, StrictRJSFSchema } from './types';
+import type { FormContextType, RJSFSchema, Widget, RegistryWidgetsType, StrictRJSFSchema } from './types';
 
 /** The map of schema types to widget type to widget name
  */
-const widgetMap: { [k: string]: { [j: string]: string } } = {
+const widgetMap: Record<string, Record<string, string>> = {
   boolean: {
     checkbox: 'CheckboxWidget',
     radio: 'RadioWidget',
@@ -74,10 +74,9 @@ function mergeWidgetOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, 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} />;
-    };
+    // oxlint-disable-next-line typescript/no-deprecated
+    const defaultOptions = AWidget.defaultProps?.options || {};
+    MergedWidget = ({ options, ...props }) => <AWidget options={{ ...defaultOptions, ...options }} {...props} />;
     set(AWidget, 'MergedWidget', MergedWidget);
   }
   return MergedWidget;

package/src/guessType.ts

@@ -17,7 +17,7 @@ export default function guessType(value: any) {
   if (typeof value === 'boolean') {
     return 'boolean';
   }
-  if (!isNaN(value)) {
+  if (typeof value === 'number' && !Number.isNaN(value)) {
     return 'number';
   }
   if (typeof value === 'object') {

package/src/hasWidget.ts

@@ -1,5 +1,5 @@
 import getWidget from './getWidget';
-import { FormContextType, RegistryWidgetsType, RJSFSchema, StrictRJSFSchema, Widget } from './types';
+import type { 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.

package/src/hashForSchema.ts

@@ -1,4 +1,4 @@
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Hashes a string using the algorithm based on Java's hashing function.
  * JS has no built-in hashing function, so rolling our own
@@ -10,10 +10,12 @@ import { RJSFSchema, StrictRJSFSchema } from './types';
  */
 export function hashString(string: string): string {
   let hash = 0;
-  for (let i = 0; i < string.length; i += 1) {
+  for (let i = 0; i < string.length; i++) {
     const chr = string.charCodeAt(i);
+    // oxlint-disable-next-line no-bitwise
     hash = (hash << 5) - hash + chr;
-    hash = hash & hash; // Convert to 32bit integer
+    // oxlint-disable-next-line no-bitwise
+    hash &= hash; // Convert to 32bit integer
   }
   return hash.toString(16);
 }
@@ -26,7 +28,10 @@ export function hashString(string: string): string {
 export function sortedJSONStringify(object: unknown): string {
   const allKeys = new Set<string>();
   // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328
-  JSON.stringify(object, (key, value) => (allKeys.add(key), value));
+  JSON.stringify(object, (key, value) => {
+    allKeys.add(key);
+    return value;
+  });
   return JSON.stringify(object, Array.from(allKeys).sort());
 }
 
@@ -42,10 +47,12 @@ export function hashObject(object: unknown): string {
 
 /** 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.
+ * Symbol-keyed properties (RJSF_REF_KEY, RJSF_REF_CYCLE_KEY, ADDITIONAL_PROPERTY_FLAG) are
+ * automatically excluded by JSON.stringify, so no special filtering is needed.
  *
  * @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) {
-  return hashObject(schema);
+  return hashString(sortedJSONStringify(schema));
 }

package/src/idGenerators.ts

@@ -1,7 +1,7 @@
 import isString from 'lodash/isString';
 
 import { ID_KEY } from './constants';
-import { FieldPathId } from './types';
+import type { FieldPathId } from './types';
 
 /** Generates a consistent `id` pattern for a given `id` and a `suffix`
  *

package/src/index.ts

@@ -18,7 +18,8 @@ import enumOptionValueEncoder from './enumOptionValueEncoder';
 import ErrorSchemaBuilder from './ErrorSchemaBuilder';
 import findSchemaDefinition from './findSchemaDefinition';
 import getChangedFields from './getChangedFields';
-import getDateElementProps, { DateElementFormat, DateElementProp } from './getDateElementProps';
+import type { DateElementFormat, DateElementProp } from './getDateElementProps';
+import getDateElementProps from './getDateElementProps';
 import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
 import getInputProps from './getInputProps';
 import getOptionMatchingSimpleDiscriminator from './getOptionMatchingSimpleDiscriminator';
@@ -51,6 +52,7 @@ import isObject from './isObject';
 import isRootSchema from './isRootSchema';
 import labelValue from './labelValue';
 import localToUTC from './localToUTC';
+import logUnsupportedDefaultForEnum from './logUnsupportedDefaultForEnum';
 import lookupFromFormContext from './lookupFromFormContext';
 import mergeDefaultsWithFormData from './mergeDefaultsWithFormData';
 import mergeObjects from './mergeObjects';
@@ -65,8 +67,11 @@ import removeOptionalEmptyObjects from './removeOptionalEmptyObjects';
 import replaceStringParameters from './replaceStringParameters';
 import resolveUiSchema from './resolveUiSchema';
 import schemaRequiresTrueValue from './schemaRequiresTrueValue';
+import SelectedOptionDescription from './SelectedOptionDescription';
+import type { SelectedOptionDescriptionProps } from './SelectedOptionDescription';
 import shallowEquals from './shallowEquals';
-import shouldRender, { ComponentUpdateStrategy } from './shouldRender';
+import type { ComponentUpdateStrategy } from './shouldRender';
+import shouldRender from './shouldRender';
 import shouldRenderOptionalField from './shouldRenderOptionalField';
 import toConstant from './toConstant';
 import toDateString from './toDateString';
@@ -74,14 +79,16 @@ import toErrorList from './toErrorList';
 import toErrorSchema from './toErrorSchema';
 import toFieldPathId from './toFieldPathId';
 import unwrapErrorHandler from './unwrapErrorHandler';
-import useAltDateWidgetProps, { DateElement, DateElementProps, UseAltDateWidgetResult } from './useAltDateWidgetProps';
+import type { DateElementProps, UseAltDateWidgetResult } from './useAltDateWidgetProps';
+import useAltDateWidgetProps, { DateElement } from './useAltDateWidgetProps';
 import useDeepCompareMemo from './useDeepCompareMemo';
-import useFileWidgetProps, { FileInfoType, UseFileWidgetPropsResult } from './useFileWidgetProps';
+import type { FileInfoType, UseFileWidgetPropsResult } from './useFileWidgetProps';
+import useFileWidgetProps from './useFileWidgetProps';
 import utcToLocal from './utcToLocal';
 import validationDataMerge from './validationDataMerge';
 import withIdRefPrefix from './withIdRefPrefix';
 
-export * from './types';
+export type * from './types';
 export * from './enums';
 
 export * from './constants';
@@ -94,6 +101,7 @@ export type {
   DateElementProp,
   DateElementProps,
   FileInfoType,
+  SelectedOptionDescriptionProps,
   UseAltDateWidgetResult,
   UseFileWidgetPropsResult,
 };
@@ -150,6 +158,7 @@ export {
   isRootSchema,
   labelValue,
   localToUTC,
+  logUnsupportedDefaultForEnum,
   lookupFromFormContext,
   mergeDefaultsWithFormData,
   mergeObjects,
@@ -161,10 +170,12 @@ export {
   pad,
   parseDateString,
   rangeSpec,
+  // oxlint-disable-next-line typescript/no-deprecated
   removeOptionalEmptyObjects,
   replaceStringParameters,
   resolveUiSchema,
   schemaRequiresTrueValue,
+  SelectedOptionDescription,
   shallowEquals,
   shouldRender,
   shouldRenderOptionalField,

package/src/isConstant.ts

@@ -1,5 +1,5 @@
 import { CONST_KEY } from './constants';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { 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.

package/src/isCustomWidget.ts

@@ -1,5 +1,5 @@
 import getUiOptions from './getUiOptions';
-import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
 
 /** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden`
  *
@@ -14,6 +14,6 @@ export default function isCustomWidget<
   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'
+    'widget' in getUiOptions<T, S, F>(uiSchema) && getUiOptions<T, S, F>(uiSchema).widget !== 'hidden'
   );
 }

package/src/isFixedItems.ts

@@ -1,12 +1,12 @@
 import isObject from './isObject';
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { 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.
+/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is an 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));
+  return Array.isArray(schema.items) && schema.items.every((item) => isObject(item));
 }

package/src/isRootSchema.ts

@@ -1,8 +1,6 @@
-import omit from 'lodash/omit';
-
-import { REF_KEY, RJSF_REF_KEY } from './constants';
+import { REF_KEY } from './constants';
 import deepEquals from './deepEquals';
-import { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types';
+import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Helper to check whether a JSON schema object is the root schema. The schema is a root schema with root `properties`
  * key or a root `$ref` key. If the `schemaToCompare` has a root `oneOf` property, the function will
@@ -25,7 +23,7 @@ export default function isRootSchema<T = any, S extends StrictRJSFSchema = RJSFS
   }
   if (REF_KEY in rootSchema) {
     const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-    return deepEquals(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
+    return deepEquals(schemaToCompare, resolvedSchema);
   }
   return false;
 }

package/src/labelValue.ts

@@ -1,4 +1,4 @@
-import { ReactElement } from 'react';
+import type { ReactElement } from 'react';
 
 /** Helper function that will return the value to use for a widget `label` based on `hideLabel`. The `fallback` is used
  * as the return value from the function when `hideLabel` is true. Due to the implementation of theme components, it

package/src/logUnsupportedDefaultForEnum.ts

@@ -0,0 +1,28 @@
+import enumOptionsIndexForValue from './enumOptionsIndexForValue';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+
+/** Logs a warning when a single-select enum widget has a schema default that is not one of its enum options.
+ *
+ * @param id - The field id used in the warning message
+ * @param schema - The schema whose default value is checked
+ * @param enumOptions - The enum options available to the widget
+ * @param multiple - Whether the widget allows multiple selections
+ */
+export default function logUnsupportedDefaultForEnum<S extends StrictRJSFSchema = RJSFSchema>(
+  id: string,
+  schema: S,
+  enumOptions?: EnumOptionsType<S>[],
+  multiple = false,
+) {
+  if (
+    !multiple &&
+    Array.isArray(enumOptions) &&
+    schema.default !== undefined &&
+    enumOptionsIndexForValue<S>(schema.default, enumOptions, multiple) === undefined
+  ) {
+    // oxlint-disable-next-line no-console
+    console.error(
+      `The schema default value "${schema.default}" is not one of the values in the enum options for "${id}"`,
+    );
+  }
+}

package/src/lookupFromFormContext.ts

@@ -2,7 +2,7 @@ import get from 'lodash/get';
 import has from 'lodash/has';
 
 import { FORM_CONTEXT_NAME, LOOKUP_MAP_NAME } from './constants';
-import { FormContextType, RJSFSchema, Registry, StrictRJSFSchema } from './types';
+import type { FormContextType, RJSFSchema, Registry, StrictRJSFSchema } from './types';
 
 /** Given a React JSON Schema Form registry or formContext object, return the value associated with `toLookup`. This
  * might be contained within the lookup map in the formContext. If no such value exists, return the `fallback`

package/src/mergeDefaultsWithFormData.ts

@@ -1,7 +1,7 @@
 import get from 'lodash/get';
 import isNil from 'lodash/isNil';
 
-import { GenericObjectType } from '../src';
+import type { GenericObjectType } from '../src';
 import isObject from './isObject';
 
 /** Merges the `defaults` object of type `T` into the `formData` of type `T`
@@ -43,7 +43,7 @@ export default function mergeDefaultsWithFormData<T = any>(
     const mapped = overrideArray.map((value, idx) => {
       // We want to explicitly make sure that the value is NOT undefined since null, 0 and empty space are valid values
       if (overrideOppositeArray[idx] !== undefined) {
-        return mergeDefaultsWithFormData<any>(
+        return mergeDefaultsWithFormData(
           defaultsArray[idx],
           formData[idx],
           mergeExtraArrayDefaults,
@@ -62,8 +62,9 @@ export default function mergeDefaultsWithFormData<T = any>(
     return mapped as unknown as T;
   }
   if (isObject(formData)) {
+    // oxlint-disable-next-line prefer-object-spread -- spread loses T type, Object.assign preserves it
     const acc: { [key in keyof T]: any } = Object.assign({}, defaults); // Prevent mutation of source object.
-    return Object.keys(formData as GenericObjectType).reduce((acc, key) => {
+    return Object.keys(formData as GenericObjectType).reduce((accumulator, key) => {
       const keyValue = get(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in (defaults as GenericObjectType);
       const keyExistsInFormData = key in (formData as GenericObjectType);
@@ -75,14 +76,14 @@ export default function mergeDefaultsWithFormData<T = any>(
       const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
 
       if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
-        acc[key as keyof T] = {
+        accumulator[key as keyof T] = {
           ...get(defaults, key),
           ...keyValue,
         };
-        return acc;
+        return accumulator;
       }
 
-      acc[key as keyof T] = mergeDefaultsWithFormData<T>(
+      accumulator[key as keyof T] = mergeDefaultsWithFormData<T>(
         get(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
@@ -103,7 +104,7 @@ export default function mergeDefaultsWithFormData<T = any>(
    */
   if (
     (defaultSupercedesUndefined &&
-      ((!(defaults === undefined) && isNil(formData)) || (typeof formData === 'number' && isNaN(formData)))) ||
+      ((!(defaults === undefined) && isNil(formData)) || (typeof formData === 'number' && Number.isNaN(formData)))) ||
     (overrideFormDataWithDefaults && !isNil(formData))
   ) {
     return defaults;

package/src/mergeObjects.ts

@@ -1,5 +1,5 @@
 import isObject from './isObject';
-import { GenericObjectType } from './types';
+import type { GenericObjectType } from './types';
 
 /** Recursively merge deeply nested objects.
  *
@@ -37,6 +37,6 @@ export default function mergeObjects(
       }
       return acc;
     },
-    Object.assign({}, obj1),
+    { ...obj1 },
   ); // Prevent mutation of source object.
 }

package/src/mergeSchemas.ts

@@ -3,7 +3,7 @@ import union from 'lodash/union';
 import { REQUIRED_KEY } from './constants';
 import getSchemaType from './getSchemaType';
 import isObject from './isObject';
-import { GenericObjectType } from './types';
+import type { GenericObjectType, GenericSymbolObjectType } from './types';
 
 /** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
  * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
@@ -14,12 +14,12 @@ import { GenericObjectType } from './types';
  * @returns - The merged schema object
  */
 export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjectType) {
-  const acc = Object.assign({}, obj1); // Prevent mutation of source object.
-  return Object.keys(obj2).reduce((acc, key) => {
+  const acc = { ...obj1 }; // Prevent mutation of source object.
+  const result = Object.keys(obj2).reduce((accumulator, key) => {
     const left = obj1 ? obj1[key] : {},
       right = obj2[key];
     if (obj1 && key in obj1 && isObject(right)) {
-      acc[key] = mergeSchemas(left, right);
+      accumulator[key] = mergeSchemas(left, right);
     } else if (
       obj1 &&
       obj2 &&
@@ -29,10 +29,17 @@ export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjec
       Array.isArray(right)
     ) {
       // Don't include duplicate values when merging 'required' fields.
-      acc[key] = union(left, right);
+      accumulator[key] = union(left, right);
     } else {
-      acc[key] = right;
+      accumulator[key] = right;
     }
-    return acc;
+    return accumulator;
   }, acc);
+  // Copy own Symbol-keyed properties from obj2 (Object.keys skips them).
+  for (const sym of Object.getOwnPropertySymbols(obj2)) {
+    // To avoid issues with symbols, we cast them to GenericSymbolObjectType. If we make the mergeSchema function take
+    // in GenericSymbolObjectType rather than GenericObjectType, it causes a bunch of type errors downstream
+    (result as GenericSymbolObjectType)[sym] = (obj2 as GenericSymbolObjectType)[sym];
+  }
+  return result;
 }

package/src/nameGenerators.ts

@@ -1,4 +1,4 @@
-import { NameGeneratorFunction, FieldPathList } from './types';
+import type { NameGeneratorFunction, FieldPathList } from './types';
 
 /**
  * Generates bracketed names

package/src/optionsList.ts

@@ -4,7 +4,7 @@ import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from './constants';
 import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
 import getUiOptions from './getUiOptions';
 import toConstant from './toConstant';
-import { RJSFSchema, EnumOptionsType, EnumValue, StrictRJSFSchema, FormContextType, UiSchema } from './types';
+import type { RJSFSchema, EnumOptionsType, EnumValue, StrictRJSFSchema, FormContextType, UiSchema } from './types';
 
 /** Reorders `options` according to `order`, which may contain a `'*'` wildcard representing all
  * remaining options in their original order. Options not listed in `order` (and not covered by
@@ -79,26 +79,24 @@ export default function optionsList<T = any, S extends StrictRJSFSchema = RJSFSc
     const { optionsSchemaSelector = selectorField } = getUiOptions<T, S, F>(uiSchema);
     selectorField = optionsSchemaSelector;
   }
-  return (
-    altSchemas &&
-    altSchemas.map((aSchemaDef, index) => {
-      const { title } = getUiOptions<T, S, F>(altUiSchemas?.[index]);
-      const aSchema = aSchemaDef as S;
-      let value: EnumOptionsType<S>['value'];
-      let label = title;
-      if (selectorField) {
-        const innerSchema: S = get(aSchema, [PROPERTIES_KEY, selectorField], {}) as S;
-        value = get(innerSchema, DEFAULT_KEY, get(innerSchema, CONST_KEY));
-        label = label || innerSchema?.title || aSchema.title || String(value);
-      } else {
-        value = toConstant(aSchema);
-        label = label || aSchema.title || String(value);
-      }
-      return {
-        schema: aSchema,
-        label,
-        value,
-      };
-    })
-  );
+  return altSchemas?.map((aSchemaDef, index) => {
+    const { title } = getUiOptions<T, S, F>(altUiSchemas?.[index]);
+    const aSchema = aSchemaDef as S;
+    let value: EnumOptionsType<S>['value'];
+    let label = title;
+    if (selectorField) {
+      const innerSchema: S = get(aSchema, [PROPERTIES_KEY, selectorField], {}) as S;
+      value = get(innerSchema, DEFAULT_KEY, get(innerSchema, CONST_KEY));
+      // Use nullish coalescing so that an explicitly empty string title is preserved
+      label = label ?? innerSchema?.title ?? aSchema.title ?? String(value);
+    } else {
+      value = toConstant(aSchema);
+      label = label ?? aSchema.title ?? String(value);
+    }
+    return {
+      schema: aSchema,
+      label,
+      value,
+    };
+  });
 }

package/src/orderProperties.ts

@@ -1,4 +1,4 @@
-import { GenericObjectType } from './types';
+import type { GenericObjectType } from './types';
 
 /** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly.
  * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per
@@ -16,9 +16,9 @@ export default function orderProperties(properties: string[], order?: string[]):
   }
 
   const arrayToHash = (arr: string[]) =>
-    arr.reduce((prev: GenericObjectType, curr) => {
-      prev[curr] = true;
-      return prev;
+    arr.reduce((acc: GenericObjectType, curr) => {
+      acc[curr] = true;
+      return acc;
     }, {});
   const errorPropList = (arr: string[]) =>
     arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;

package/src/pad.ts

@@ -7,7 +7,7 @@
 export default function pad(num: number, width: number) {
   let s = String(num);
   while (s.length < width) {
-    s = '0' + s;
+    s = `0${s}`;
   }
   return s;
 }