@rjsf/utils 6.4.1 → 6.5.0

package/lib/types.d.ts

@@ -20,6 +20,13 @@ export type FormContextType = GenericObjectType;
 /** The interface for the test ID proxy objects that are returned by the `getTestId` utility function.
  */
 export type TestIdShape = Record<string, string>;
+/** Controls how enum-backed widgets encode option values in their DOM `value` attributes.
+ *
+ * - `'indexed'`: options are encoded as their array index (default, historical behavior).
+ * - `'realValue'`: primitive option values are stringified directly, enabling native form
+ *   submission. Object/array values still fall back to their index.
+ */
+export type OptionValueFormat = 'indexed' | 'realValue';
 /** Function to generate HTML name attributes from path segments */
 export type NameGeneratorFunction = (path: FieldPathList, idPrefix: string, isMultiValue?: boolean) => string;
 /** Experimental feature that specifies the Array `minItems` default form state behavior
@@ -125,11 +132,15 @@ export type RangeSpecType = {
     max?: number;
 };
 /** Properties describing a Range specification in terms of attribute that can be added to the `HTML` `<input>` */
-export type InputPropsType = Omit<RangeSpecType, 'step'> & {
+export type InputPropsType = {
     /** Specifies the type of the <input> element */
     type: string;
     /** Specifies the interval between legal numbers in an input field or "any" */
     step?: number | 'any';
+    /** Specifies a minimum value for an <input> element; accepts a number for numeric inputs or a string for date/time inputs */
+    min?: number | string;
+    /** Specifies the maximum value for an <input> element; accepts a number for numeric inputs or a string for date/time inputs */
+    max?: number | string;
     /** Specifies the `autoComplete` value for an <input> element */
     autoComplete?: HTMLInputElement['autocomplete'];
     /** Specifies a filter for what file types the user can upload. */
@@ -357,6 +368,21 @@ export type GlobalUISchemaOptions = GenericObjectType & {
      * both. To disable the Optional Data Field UI for a specific field, provide an empty array within the UI schema.
      */
     enableOptionalDataFieldForType?: ('object' | 'array')[];
+    /** Controls how enum-backed widgets (select, radio, checkboxes) encode option values
+     *  in their DOM `value` attributes.
+     *
+     *  - `'indexed'` (default): options are encoded as their array index. This is the
+     *    historical behavior and keeps object/array enum values addressable without
+     *    stringifying them.
+     *  - `'realValue'`: primitive option values are stringified directly (e.g. `"foo"`,
+     *    `"42"`, `"true"`). This enables native form submission and browser autocomplete
+     *    since the submitted value matches the enum value. Object/array values still
+     *    fall back to their index since `String(obj)` would produce `"[object Object]"`.
+     *
+     *  The form data passed to `onChange` is always the typed enum value; this option
+     *  only affects the DOM-level encoding.
+     */
+    optionValueFormat?: OptionValueFormat;
 };
 /** The set of options from the `Form` that will be available on the `Registry` for use in everywhere the `registry` is
  * available.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rjsf/utils",
-  "version": "6.4.1",
+  "version": "6.5.0",
   "main": "dist/index.js",
   "module": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -65,11 +65,11 @@
     "react": ">=18"
   },
   "dependencies": {
-    "@x0k/json-schema-merge": "^1.0.2",
+    "@x0k/json-schema-merge": "^1.0.3",
     "fast-uri": "^3.1.0",
     "jsonpointer": "^5.0.1",
-    "lodash": "^4.17.23",
-    "lodash-es": "^4.17.23",
+    "lodash": "^4.18.1",
+    "lodash-es": "^4.18.1",
     "react-is": "^18.3.1"
   },
   "devDependencies": {

package/src/enumOptionSelectedValue.ts

@@ -0,0 +1,39 @@
+import { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
+import enumOptionsIndexForValue from './enumOptionsIndexForValue';
+
+/** Computes the value to pass to a select element's `value` attribute.
+ *
+ * When `format` is `'realValue'`, converts form data values to strings.
+ * When `format` is `'indexed'` (the default), resolves to index-based values via
+ * `enumOptionsIndexForValue`. Returns `emptyValue` when the current value is empty.
+ *
+ * @param value - The current form data value
+ * @param enumOptions - The available enum options
+ * @param multiple - Whether the select allows multiple selections
+ * @param [format='indexed'] - How option values are encoded on the DOM
+ * @param emptyValue - The value to return when the selection is empty
+ * @returns The value to use for the select element's `value` attribute
+ */
+export default function enumOptionSelectedValue<S extends StrictRJSFSchema = RJSFSchema>(
+  value: any,
+  enumOptions: EnumOptionsType<S>[] | undefined,
+  multiple: boolean,
+  format: OptionValueFormat = 'indexed',
+  emptyValue?: any,
+): any {
+  const isEmpty =
+    typeof value === 'undefined' ||
+    (multiple && Array.isArray(value) && value.length < 1) ||
+    (!multiple && value === emptyValue);
+
+  if (isEmpty) {
+    return emptyValue;
+  }
+
+  if (format === 'realValue') {
+    return multiple ? value.map(String) : String(value);
+  }
+
+  const indexes = enumOptionsIndexForValue<S>(value, enumOptions, multiple);
+  return typeof indexes === 'undefined' ? emptyValue : indexes;
+}

package/src/enumOptionValueDecoder.ts

@@ -0,0 +1,64 @@
+import { EnumOptionsType, OptionValueFormat, StrictRJSFSchema, RJSFSchema } from './types';
+import enumOptionsValueForIndex from './enumOptionsValueForIndex';
+
+/** Resolves a single DOM value string back to its typed enum value in `'realValue'` mode.
+ *
+ * First attempts a reverse lookup by matching `String(opt.value)` against the input.
+ * If no option matches and the input parses as a valid index, falls back to the
+ * option at that index — this is how object/array enum values round-trip, since
+ * they are encoded as indices by the encoder.
+ *
+ * @param value - A single string value from a DOM attribute
+ * @param enumOptions - The available enum options
+ * @param emptyValue - The value to return when the input is empty, options are missing, or no match is found
+ * @returns The original typed enum value, or `emptyValue`
+ */
+function decodeSingle<S extends StrictRJSFSchema = RJSFSchema>(
+  value: string,
+  enumOptions: EnumOptionsType<S>[] | undefined,
+  emptyValue?: unknown,
+): unknown {
+  if (value === '' || !Array.isArray(enumOptions)) {
+    return emptyValue;
+  }
+  const match = enumOptions.find((opt) => String(opt.value) === value);
+  if (match) {
+    return match.value;
+  }
+  // Fallback: value might be an index (for object/array enum values)
+  const index = Number(value);
+  if (!isNaN(index) && index >= 0 && index < enumOptions.length) {
+    return enumOptions[index].value;
+  }
+  return emptyValue;
+}
+
+/** Decodes a string from a DOM value attribute back to a typed enum value.
+ *
+ * When `format` is `'realValue'`, does a reverse lookup: finds the enum option
+ * whose `String(value)` matches the input string and returns the original typed value.
+ * For object/array values that were encoded as indices, falls back to index resolution.
+ *
+ * When `format` is `'indexed'` (the default), uses index-based resolution via
+ * `enumOptionsValueForIndex`.
+ *
+ * @param value - The string value(s) from the DOM
+ * @param enumOptions - The available enum options
+ * @param [format='indexed'] - How the values were encoded on the DOM
+ * @param emptyValue - The value to return for empty/missing selections
+ * @returns The original typed enum value(s)
+ */
+export default function enumOptionValueDecoder<S extends StrictRJSFSchema = RJSFSchema>(
+  value: string | string[],
+  enumOptions: EnumOptionsType<S>[] | undefined,
+  format: OptionValueFormat = 'indexed',
+  emptyValue?: unknown,
+): unknown {
+  if (format !== 'realValue') {
+    return enumOptionsValueForIndex<S>(value, enumOptions, emptyValue);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => decodeSingle(v, enumOptions, emptyValue));
+  }
+  return decodeSingle(value, enumOptions, emptyValue);
+}

package/src/enumOptionValueEncoder.ts

@@ -0,0 +1,33 @@
+import isNil from 'lodash/isNil';
+
+import { OptionValueFormat } from './types';
+
+/** Encodes an enum option value into a string for a DOM value attribute.
+ *
+ * When `format` is `'realValue'`, primitive values are converted via `String()`.
+ * Non-primitive values (objects, arrays) fall back to the index since
+ * `String()` would produce `"[object Object]"`.
+ *
+ * When `format` is `'indexed'` (the default), returns the index as a string.
+ *
+ * @param value - The typed enum value
+ * @param index - The option's position in the enumOptions array
+ * @param [format='indexed'] - How to encode the value for the DOM attribute
+ * @returns The string to use as the DOM value attribute
+ */
+export default function enumOptionValueEncoder(
+  value: unknown,
+  index: number,
+  format: OptionValueFormat = 'indexed',
+): string {
+  if (format !== 'realValue') {
+    return String(index);
+  }
+  if (isNil(value)) {
+    return '';
+  }
+  if (typeof value === 'object') {
+    return String(index);
+  }
+  return String(value);
+}

package/src/getInputProps.ts

@@ -47,6 +47,16 @@ export default function getInputProps<
     }
   }
 
+  // For date/time input types, propagate formatMinimum/formatMaximum to min/max
+  if (['date', 'datetime-local', 'time', 'week', 'month'].includes(inputProps.type)) {
+    if (schema.formatMinimum !== undefined) {
+      inputProps.min = schema.formatMinimum as string;
+    }
+    if (schema.formatMaximum !== undefined) {
+      inputProps.max = schema.formatMaximum as string;
+    }
+  }
+
   if (options.autocomplete) {
     inputProps.autoComplete = options.autocomplete;
   }

package/src/getOptionValueFormat.ts

@@ -0,0 +1,17 @@
+import { OptionValueFormat } from './types';
+
+/** Resolves the effective `optionValueFormat` for enum-backed widgets.
+ *
+ * Provides a single source of truth for the default DOM encoding format
+ * (`'indexed'`) used by `SelectWidget`, `RadioWidget`, and `CheckboxesWidget`.
+ * Widgets should call this helper once and pass the result to
+ * `enumOptionValueEncoder`, `enumOptionValueDecoder`, and `enumOptionSelectedValue`
+ * rather than reading `options.optionValueFormat` directly.
+ *
+ * @param options - The widget options (typically from the `options` prop, already
+ *   resolved from `ui:options` and `ui:globalOptions`)
+ * @returns The resolved `OptionValueFormat`, defaulting to `'indexed'` when not set
+ */
+export default function getOptionValueFormat(options?: { optionValueFormat?: OptionValueFormat }): OptionValueFormat {
+  return options?.optionValueFormat ?? 'indexed';
+}

package/src/index.ts

@@ -8,6 +8,9 @@ import dateRangeOptions from './dateRangeOptions';
 import deepEquals from './deepEquals';
 import shallowEquals from './shallowEquals';
 import englishStringTranslator from './englishStringTranslator';
+import enumOptionSelectedValue from './enumOptionSelectedValue';
+import enumOptionValueDecoder from './enumOptionValueDecoder';
+import enumOptionValueEncoder from './enumOptionValueEncoder';
 import enumOptionsDeselectValue from './enumOptionsDeselectValue';
 import enumOptionsIndexForValue from './enumOptionsIndexForValue';
 import enumOptionsIsSelected from './enumOptionsIsSelected';
@@ -20,6 +23,7 @@ import getDateElementProps, { DateElementFormat, DateElementProp } from './getDa
 import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
 import getInputProps from './getInputProps';
 import getOptionMatchingSimpleDiscriminator from './getOptionMatchingSimpleDiscriminator';
+import getOptionValueFormat from './getOptionValueFormat';
 import getSchemaType from './getSchemaType';
 import getSubmitButtonOptions from './getSubmitButtonOptions';
 import getTemplate from './getTemplate';
@@ -53,12 +57,13 @@ import mergeDefaultsWithFormData from './mergeDefaultsWithFormData';
 import mergeObjects from './mergeObjects';
 import mergeSchemas from './mergeSchemas';
 import optionsList from './optionsList';
+import removeOptionalEmptyObjects from './removeOptionalEmptyObjects';
 import orderProperties from './orderProperties';
 import pad from './pad';
 import parseDateString from './parseDateString';
 import rangeSpec from './rangeSpec';
 import replaceStringParameters from './replaceStringParameters';
-import resolveUiSchema, { expandUiSchemaDefinitions } from './resolveUiSchema';
+import resolveUiSchema from './resolveUiSchema';
 import schemaRequiresTrueValue from './schemaRequiresTrueValue';
 import shouldRender, { ComponentUpdateStrategy } from './shouldRender';
 import shouldRenderOptionalField from './shouldRenderOptionalField';
@@ -107,6 +112,9 @@ export {
   deepEquals,
   descriptionId,
   englishStringTranslator,
+  enumOptionSelectedValue,
+  enumOptionValueDecoder,
+  enumOptionValueEncoder,
   enumOptionsDeselectValue,
   enumOptionsIndexForValue,
   enumOptionsIsSelected,
@@ -121,6 +129,7 @@ export {
   getDiscriminatorFieldFromSchema,
   getInputProps,
   getOptionMatchingSimpleDiscriminator,
+  getOptionValueFormat,
   getSchemaType,
   getSubmitButtonOptions,
   getTemplate,
@@ -152,9 +161,9 @@ export {
   pad,
   parseDateString,
   rangeSpec,
+  removeOptionalEmptyObjects,
   replaceStringParameters,
   resolveUiSchema,
-  expandUiSchemaDefinitions,
   schemaRequiresTrueValue,
   shallowEquals,
   shouldRender,

package/src/removeOptionalEmptyObjects.ts

@@ -0,0 +1,127 @@
+import isNil from 'lodash/isNil';
+
+import isObject from './isObject';
+import { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from './types';
+import retrieveSchema from './schema/retrieveSchema';
+
+/** Determines whether a value is considered "empty" for the purposes of optional object pruning.
+ * A value is empty if it is `undefined`, `null`, an empty string, or an object where all own
+ * properties are themselves empty.
+ *
+ * @param value - The value to check
+ * @returns True if the value is considered empty
+ */
+function isValueEmpty(value: unknown): boolean {
+  if (isNil(value) || value === '') {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    // An empty array is considered empty; a non-empty array is not
+    return value.length === 0;
+  }
+  if (isObject(value)) {
+    const obj = value as GenericObjectType;
+    const keys = Object.keys(obj);
+    return keys.every((key) => isValueEmpty(obj[key]));
+  }
+  return false;
+}
+
+/** Recursively removes optional objects from the `formData` that are empty (i.e., all their fields
+ * are undefined, null, empty strings, or themselves empty optional objects). This solves the problem
+ * where interacting with fields inside an optional object "activates" it permanently, making the
+ * form unsubmittable when the optional object has required inner fields.
+ *
+ * An object property is considered "optional" when it is NOT listed in its parent schema's `required`
+ * array.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The JSON schema describing the `formData`
+ * @param [rootSchema] - The root schema, used primarily to look up `$ref`s
+ * @param [formData] - The current form data to prune
+ * @returns - A new copy of `formData` with empty optional objects removed, or `undefined` if the
+ *           entire formData was pruned
+ */
+export default function removeOptionalEmptyObjects<
+  T = any,
+  S extends StrictRJSFSchema = RJSFSchema,
+  F extends FormContextType = any,
+>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S, formData?: T): T | undefined {
+  if (!isObject(schema)) {
+    return formData;
+  }
+
+  const resolvedSchema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData);
+
+  if (Array.isArray(formData)) {
+    const itemsSchema = resolvedSchema.items as S | S[];
+    if (!itemsSchema) {
+      return formData;
+    }
+
+    let hasChanges = false;
+    const mapped = formData.map((item, index) => {
+      let itemSchema = itemsSchema as S;
+      if (Array.isArray(itemsSchema)) {
+        itemSchema = itemsSchema[index] || (resolvedSchema.additionalItems as S) || ({} as S);
+      }
+      const cleaned = removeOptionalEmptyObjects<T, S, F>(validator, itemSchema, rootSchema, item);
+      if (cleaned !== item) {
+        hasChanges = true;
+      }
+      return cleaned === undefined ? ({} as T) : cleaned;
+    });
+
+    // Although T is an array type here, we still need to cast it back to T since TS
+    // doesn't narrow the generic T automatically
+    return hasChanges ? (mapped as T) : formData;
+  }
+
+  const { properties, required: requiredFields = [] } = resolvedSchema;
+
+  if (!isObject(formData) || !properties) {
+    return formData;
+  }
+
+  const result: GenericObjectType = {};
+  const data = formData as GenericObjectType;
+  let hasAnyValue = false;
+
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const propertySchema = (properties[key] || {}) as S;
+    const isRequired = (requiredFields as string[]).includes(key);
+
+    const isObj = isObject(value);
+    const isArr = Array.isArray(value);
+
+    if ((isObj || isArr) && properties[key]) {
+      // Recursively process nested objects and arrays
+      const cleaned = removeOptionalEmptyObjects<T, S, F>(validator, propertySchema, rootSchema, value as T);
+
+      if (!isRequired && isValueEmpty(cleaned)) {
+        // This is an optional property and the cleaned result is empty — omit it
+        continue;
+      }
+
+      result[key] = cleaned;
+      hasAnyValue = true;
+    } else if (!isRequired && isValueEmpty(value) && properties[key]) {
+      // Optional scalar property that is empty — omit it
+      continue;
+    } else {
+      result[key] = value;
+      if (!isValueEmpty(value)) {
+        hasAnyValue = true;
+      }
+    }
+  }
+
+  // If the entire object ended up empty after pruning, return undefined so that the
+  // caller (which may itself be a recursive call) can decide whether to keep or drop it
+  if (!hasAnyValue && Object.keys(result).length === 0) {
+    return undefined;
+  }
+
+  return result as T;
+}

package/src/resolveUiSchema.ts

@@ -1,112 +1,81 @@
-import {
-  ADDITIONAL_PROPERTIES_KEY,
-  ALL_OF_KEY,
-  ANY_OF_KEY,
-  ITEMS_KEY,
-  ONE_OF_KEY,
-  PROPERTIES_KEY,
-  REF_KEY,
-  RJSF_REF_KEY,
-} from './constants';
+import isEmpty from 'lodash/isEmpty';
+
+import { ANY_OF_KEY, ONE_OF_KEY, REF_KEY, RJSF_REF_KEY } from './constants';
 import findSchemaDefinition from './findSchemaDefinition';
-import isObject from './isObject';
 import mergeObjects from './mergeObjects';
 import { FormContextType, GenericObjectType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
 
-// Keywords where child schemas map to uiSchema at the SAME key
-const SAME_KEY_KEYWORDS = [ITEMS_KEY, ADDITIONAL_PROPERTIES_KEY] as const;
-
-// Keywords where child schemas are in an array, each mapping to uiSchema[keyword][i]
-const ARRAY_KEYWORDS = [ONE_OF_KEY, ANY_OF_KEY, ALL_OF_KEY] as const;
-
-/** Expands `ui:definitions` into the uiSchema by walking the schema tree and finding all `$ref`s.
- * Called once at form initialization to pre-expand definitions into the uiSchema structure.
+/** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
  *
- * For recursive schemas, expansion stops at recursion points to avoid infinite loops.
- * Runtime resolution via `resolveUiSchema` handles these cases using registry definitions.
+ * Called at runtime for each field. When the schema contains a `$ref`, looks up the corresponding
+ * uiSchema definition from `registry.uiSchemaDefinitions` and merges it with local overrides.
+ * For schemas with `oneOf`/`anyOf` branches, also populates `uiSchema[keyword][i]` for branches
+ * whose `$ref` matches a definition, so `MultiSchemaField` can read dropdown option titles.
  *
- * @param currentSchema - The current schema node being processed
- * @param uiSchema - The uiSchema at the current path
- * @param registry - The registry containing rootSchema and uiSchemaDefinitions
- * @param visited - Set of $refs already visited (to detect recursion)
- * @returns - The expanded uiSchema with definitions merged in
+ * Resolution order (later sources override earlier):
+ * 1. `ui:definitions[$ref]` - base definition from registry
+ * 2. `localUiSchema` - local overrides at current path
+ *
+ * @param schema - The JSON schema (may contain `$ref` or `RJSF_REF_KEY`)
+ * @param localUiSchema - The uiSchema at the current path (local overrides)
+ * @param registry - The registry containing `uiSchemaDefinitions`
+ * @returns - The resolved uiSchema with definitions merged in
  */
-export function expandUiSchemaDefinitions<
+export default function resolveUiSchema<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
->(
-  currentSchema: S,
-  uiSchema: UiSchema<T, S, F>,
-  registry: Registry<T, S, F>,
-  visited: Set<string> = new Set(),
-): UiSchema<T, S, F> {
-  const { rootSchema, uiSchemaDefinitions: definitions } = registry;
-  let result = { ...uiSchema };
-  let resolvedSchema = currentSchema;
-
-  const ref = currentSchema[REF_KEY] as string | undefined;
-  const isRecursive = ref && visited.has(ref);
-
-  if (ref) {
-    visited.add(ref);
-
-    if (definitions && ref in definitions) {
-      result = mergeObjects(definitions[ref] as GenericObjectType, result as GenericObjectType) as UiSchema<T, S, F>;
-    }
-
-    if (isRecursive) {
-      return result;
-    }
+>(schema: S, localUiSchema: UiSchema<T, S, F> | undefined, registry: Registry<T, S, F>): UiSchema<T, S, F> {
+  const ref = ((schema as GenericObjectType)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
+  const definitions = registry.uiSchemaDefinitions;
+  const definitionUiSchema = ref && definitions ? definitions[ref] : undefined;
 
-    try {
-      resolvedSchema = findSchemaDefinition<S>(ref, rootSchema as S);
-    } catch {
-      resolvedSchema = currentSchema;
-    }
+  let result: UiSchema<T, S, F>;
+  if (!definitionUiSchema) {
+    result = localUiSchema || {};
+  } else if (!localUiSchema || isEmpty(localUiSchema)) {
+    result = { ...definitionUiSchema };
+  } else {
+    result = mergeObjects(definitionUiSchema as GenericObjectType, localUiSchema as GenericObjectType) as UiSchema<
+      T,
+      S,
+      F
+    >;
   }
 
-  // Process properties (each property maps to uiSchema[propName] - flattened)
-  const properties = resolvedSchema[PROPERTIES_KEY];
-  if (properties && isObject(properties)) {
-    for (const [propName, propSchema] of Object.entries(properties as Record<string, S>)) {
-      const propUiSchema = (result[propName] || {}) as UiSchema<T, S, F>;
-      const expanded = expandUiSchemaDefinitions(propSchema, propUiSchema, registry, new Set(visited));
-      if (Object.keys(expanded).length > 0) {
-        result[propName] = expanded;
+  // Walk oneOf/anyOf branches to populate uiSchema[keyword][i] so MultiSchemaField
+  // can read dropdown option titles at the parent level.
+  if (definitions) {
+    let resolvedSchema: S = schema;
+    if (ref && schema[REF_KEY] && !(schema as GenericObjectType)[RJSF_REF_KEY]) {
+      try {
+        resolvedSchema = findSchemaDefinition<S>(ref, registry.rootSchema as S);
+      } catch (e) {
+        console.warn('could not resolve $ref in resolveUiSchema:\n', e);
+        return result;
       }
     }
-  }
 
-  // Process keywords where child maps to same key in uiSchema (items, additionalProperties)
-  for (const keyword of SAME_KEY_KEYWORDS) {
-    const subSchema = resolvedSchema[keyword];
-    if (subSchema && isObject(subSchema) && !Array.isArray(subSchema)) {
-      const currentUiSchema = result[keyword];
-      if (typeof currentUiSchema !== 'function') {
-        const subUiSchema = ((currentUiSchema as GenericObjectType) || {}) as UiSchema<T, S, F>;
-        const expanded = expandUiSchemaDefinitions(subSchema as S, subUiSchema, registry, new Set(visited));
-        if (Object.keys(expanded).length > 0) {
-          (result as GenericObjectType)[keyword] = expanded;
-        }
+    for (const keyword of [ONE_OF_KEY, ANY_OF_KEY] as const) {
+      const schemaOptions = resolvedSchema[keyword];
+      if (!Array.isArray(schemaOptions) || schemaOptions.length === 0) {
+        continue;
       }
-    }
-  }
 
-  // Process array keywords (oneOf, anyOf, allOf) - each option maps to uiSchema[keyword][i]
-  for (const keyword of ARRAY_KEYWORDS) {
-    const schemaOptions = resolvedSchema[keyword];
-    if (Array.isArray(schemaOptions) && schemaOptions.length > 0) {
       const currentUiSchemaArray = (result as GenericObjectType)[keyword];
       const uiSchemaArray: UiSchema<T, S, F>[] = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
 
       let hasExpanded = false;
       for (let i = 0; i < schemaOptions.length; i++) {
-        const optionSchema = schemaOptions[i] as S;
-        const optionUiSchema = (uiSchemaArray[i] || {}) as UiSchema<T, S, F>;
-        const expanded = expandUiSchemaDefinitions(optionSchema, optionUiSchema, registry, new Set(visited));
-        if (Object.keys(expanded).length > 0) {
-          uiSchemaArray[i] = expanded;
+        const option = schemaOptions[i] as GenericObjectType | undefined;
+        const optionRef = (option?.[RJSF_REF_KEY] ?? option?.[REF_KEY]) as string | undefined;
+        if (optionRef && optionRef in definitions) {
+          const optionUiSchema = (uiSchemaArray[i] || {}) as GenericObjectType;
+          uiSchemaArray[i] = mergeObjects(definitions[optionRef] as GenericObjectType, optionUiSchema) as UiSchema<
+            T,
+            S,
+            F
+          >;
           hasExpanded = true;
         }
       }
@@ -119,39 +88,3 @@ export function expandUiSchemaDefinitions<
 
   return result;
 }
-
-/** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
- *
- * This function is called at runtime for each field. It handles recursive schemas where the
- * pre-expansion in `expandUiSchemaDefinitions` couldn't go deeper.
- *
- * When the schema contains a `$ref`, this function looks up the corresponding uiSchema definition
- * from `registry.uiSchemaDefinitions` and merges it with any local uiSchema overrides.
- *
- * Resolution order (later sources override earlier):
- * 1. `ui:definitions[$ref]` - base definition from registry
- * 2. `localUiSchema` - local overrides at current path
- *
- * @param schema - The JSON schema (may still contain `$ref` for recursive schemas)
- * @param localUiSchema - The uiSchema at the current path (local overrides)
- * @param registry - The registry containing `uiSchemaDefinitions`
- * @returns - The resolved uiSchema with definitions merged in
- */
-export default function resolveUiSchema<
-  T = any,
-  S extends StrictRJSFSchema = RJSFSchema,
-  F extends FormContextType = any,
->(schema: S, localUiSchema: UiSchema<T, S, F> | undefined, registry: Registry<T, S, F>): UiSchema<T, S, F> {
-  const ref = ((schema as GenericObjectType)[RJSF_REF_KEY] ?? schema[REF_KEY]) as string | undefined;
-  const definitionUiSchema = ref ? registry.uiSchemaDefinitions?.[ref] : undefined;
-
-  if (!definitionUiSchema) {
-    return localUiSchema || {};
-  }
-
-  if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
-    return { ...definitionUiSchema };
-  }
-
-  return mergeObjects(definitionUiSchema as GenericObjectType, localUiSchema as GenericObjectType) as UiSchema<T, S, F>;
-}