@rjsf/utils 6.6.1 → 6.7.0

package/src/schema/retrieveSchema.ts

@@ -20,6 +20,7 @@ import {
   PATTERN_PROPERTIES_KEY,
   PROPERTIES_KEY,
   REF_KEY,
+  RJSF_REF_CYCLE_KEY,
   RJSF_REF_KEY,
 } from '../constants';
 import deepEquals from '../deepEquals';
@@ -28,10 +29,11 @@ import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema'
 import guessType from '../guessType';
 import isObject from '../isObject';
 import mergeSchemas from '../mergeSchemas';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   GenericObjectType,
+  RJSFMarkedSchema,
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
@@ -75,6 +77,18 @@ export default function retrieveSchema<
   )[0];
 }
 
+/** Converts boolean schemas to equivalent object schemas for APIs that operate on `StrictRJSFSchema` objects.
+ *
+ * @param schema - The schema or boolean schema to normalize
+ * @returns - The original schema or an equivalent object schema
+ */
+function normalizeBooleanSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S | boolean): S {
+  if (typeof schema !== 'boolean') {
+    return schema;
+  }
+  return (schema ? {} : { not: {} }) as S;
+}
+
 /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
  * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
  * conditions will be returned.
@@ -105,10 +119,11 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
   let schemas: S[] = [];
   if (expandAllBranches) {
     if (then && typeof then !== 'boolean') {
+      const thenSchema = then as unknown as S;
       schemas = schemas.concat(
         retrieveSchemaInternal<T, S, F>(
           validator,
-          then as S,
+          thenSchema,
           rootSchema,
           formData,
           expandAllBranches,
@@ -118,10 +133,11 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
       );
     }
     if (otherwise && typeof otherwise !== 'boolean') {
+      const otherwiseSchema = otherwise as unknown as S;
       schemas = schemas.concat(
         retrieveSchemaInternal<T, S, F>(
           validator,
-          otherwise as S,
+          otherwiseSchema,
           rootSchema,
           formData,
           expandAllBranches,
@@ -131,12 +147,13 @@ export function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchem
       );
     }
   } else {
-    const conditionalSchema = conditionValue ? then : otherwise;
-    if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
+    const conditionalBranch = (conditionValue ? then : otherwise) as S | boolean | undefined;
+    if (conditionalBranch !== undefined) {
+      const conditionalSchema = normalizeBooleanSchema<S>(conditionalBranch);
       schemas = schemas.concat(
         retrieveSchemaInternal<T, S, F>(
           validator,
-          conditionalSchema as S,
+          conditionalSchema,
           rootSchema,
           formData,
           expandAllBranches,
@@ -187,7 +204,7 @@ export function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchem
       permutations.forEach((permutation) => permutation.push(list[0]));
       return permutations;
     },
-    [[]] as S[][], // Start with an empty list
+    [[]], // Start with an empty list
   );
 
   return allPermutations;
@@ -265,8 +282,8 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
       formData,
       experimental_customMergeAllOf,
     );
-    return resolvedSchemas.flatMap((s) => {
-      return retrieveSchemaInternal<T, S, F>(
+    return resolvedSchemas.flatMap((s) =>
+      retrieveSchemaInternal<T, S, F>(
         validator,
         s,
         rootSchema,
@@ -274,8 +291,8 @@ export function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema,
         expandAllBranches,
         recurseList,
         experimental_customMergeAllOf,
-      );
-    });
+      ),
+    );
   }
   if (ALL_OF_KEY in schema && Array.isArray(schema[ALL_OF_KEY])) {
     const allOfSchemaElements: S[][] = schema.allOf.map((allOfSubschema) =>
@@ -348,6 +365,10 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param recurseList - List of $refs already resolved to prevent recursion
  * @param [baseURI] - The base URI to be used for resolving relative references
  * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
+ * @param [markCycleOnDetection=false] - When true and a recursive $ref is detected, the returned schema is tagged
+ *   with `__rjsf_ref_cycle: true` so that `SchemaField` can render a cycle indicator instead of recursing.
+ *   Should only be `true` when called from an **object-property** context, because object properties are always
+ *   rendered (creating an infinite loop), whereas array items and anyOf/oneOf branches are data-driven.
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
@@ -356,24 +377,26 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   recurseList: string[],
   baseURI?: string,
   resolveAnyOfOrOneOfRefs?: boolean,
+  markCycleOnDetection = false,
 ): S {
   if (!isObject(schema)) {
     return schema;
   }
   let resolvedSchema: S = schema;
+  let currentBaseURI = baseURI;
   // resolve top level ref
   if (REF_KEY in resolvedSchema) {
     const { $ref, ...localSchema } = resolvedSchema;
     // Check for a recursive reference and stop the loop
     if (recurseList.includes($ref!)) {
-      return resolvedSchema;
+      return markCycleOnDetection ? ({ ...resolvedSchema, [RJSF_REF_CYCLE_KEY]: true } as S) : resolvedSchema;
     }
     recurseList.push($ref!);
     // Retrieve the referenced schema definition.
-    const refSchema = findSchemaDefinition<S>($ref, rootSchema, baseURI);
+    const refSchema = findSchemaDefinition<S>($ref, rootSchema, currentBaseURI);
     resolvedSchema = { ...refSchema, ...localSchema, [RJSF_REF_KEY]: $ref };
     if (ID_KEY in resolvedSchema) {
-      baseURI = resolvedSchema[ID_KEY];
+      currentBaseURI = resolvedSchema[ID_KEY];
     }
   }
 
@@ -381,9 +404,20 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     const childrenLists: string[][] = [];
     const updatedProps = transform(
       resolvedSchema[PROPERTIES_KEY]!,
-      (result, value, key: string) => {
+      (acc, value, key: string) => {
         const childList: string[] = [...recurseList];
-        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI, resolveAnyOfOrOneOfRefs);
+        // Mark cycles only when NOT in resolveAnyOfOrOneOfRefs mode. When resolveAnyOfOrOneOfRefs=true
+        // (e.g. from ObjectField), options are resolved against a shared recurseList that accumulates
+        // refs across branches, causing false positives. In simple (non-anyOf) resolution, a $ref cycle
+        // in an object property always causes an infinite render loop and must be caught.
+        acc[key] = resolveAllReferences(
+          value as S,
+          rootSchema,
+          childList,
+          currentBaseURI,
+          resolveAnyOfOrOneOfRefs,
+          !resolveAnyOfOrOneOfRefs,
+        );
         childrenLists.push(childList);
       },
       {} as RJSFSchema,
@@ -399,7 +433,14 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   ) {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs),
+      // Array items are only rendered when data exists, so a $ref cycle here does NOT cause an infinite render.
+      items: resolveAllReferences(
+        resolvedSchema.items as S,
+        rootSchema,
+        recurseList,
+        currentBaseURI,
+        resolveAnyOfOrOneOfRefs,
+      ),
     };
   }
 
@@ -417,7 +458,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
       resolvedSchema = {
         ...resolvedSchema,
         [key]: schemas.map((s: S) =>
-          resolveAllReferences(s, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs),
+          resolveAllReferences(s, rootSchema, recurseList, currentBaseURI, resolveAnyOfOrOneOfRefs),
         ),
       };
     }
@@ -469,7 +510,7 @@ export function stubExistingAdditionalProperties<
           get(formData, [key]) as T,
           experimental_customMergeAllOf,
         );
-        set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+        (schema.properties[key] as RJSFMarkedSchema)[ADDITIONAL_PROPERTY_FLAG] = true;
         return;
       }
     }
@@ -481,7 +522,7 @@ export function stubExistingAdditionalProperties<
             validator,
             { [REF_KEY]: get(schema.additionalProperties, [REF_KEY]) } as S,
             rootSchema,
-            formData as T,
+            get(formData, [key]) as T,
             experimental_customMergeAllOf,
           );
         } else if ('type' in schema.additionalProperties!) {
@@ -501,12 +542,12 @@ export function stubExistingAdditionalProperties<
       // The type of our new key should match the additionalProperties value;
       schema.properties[key] = additionalProperties;
       // Set our additional property flag so we know it was dynamically added
-      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+      (schema.properties[key] as RJSFMarkedSchema)[ADDITIONAL_PROPERTY_FLAG] = true;
     } else {
       // Invalid property
       schema.properties[key] = { type: 'null' };
       // Set our additional property flag so we know it was dynamically added
-      set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
+      (schema.properties[key] as RJSFMarkedSchema)[ADDITIONAL_PROPERTY_FLAG] = true;
     }
   });
 
@@ -588,11 +629,19 @@ export function retrieveSchemaInternal<
       try {
         const withContainsSchemas = [] as S[];
         const withoutContainsSchemas = [] as S[];
-        resolvedSchema.allOf?.forEach((s) => {
-          if (typeof s === 'object' && s.contains) {
-            withContainsSchemas.push(s as S);
+        // Collect Symbol-keyed properties from allOf subschemas before merging; shallowAllOfMerge
+        // (external library) only operates on string keys and will drop them.
+        const allOfSymbols: Record<symbol, unknown> = {};
+        resolvedSchema.allOf?.forEach((allOfItem) => {
+          if (typeof allOfItem === 'object' && allOfItem.contains) {
+            withContainsSchemas.push(allOfItem as S);
           } else {
-            withoutContainsSchemas.push(s as S);
+            withoutContainsSchemas.push(allOfItem as S);
+            for (const sym of Object.getOwnPropertySymbols(allOfItem)) {
+              if (!(sym in allOfSymbols)) {
+                allOfSymbols[sym] = (allOfItem as any)[sym];
+              }
+            }
           }
         });
         if (withContainsSchemas.length) {
@@ -601,10 +650,15 @@ export function retrieveSchemaInternal<
         resolvedSchema = experimental_customMergeAllOf
           ? experimental_customMergeAllOf(resolvedSchema)
           : mergeAllOf(resolvedSchema);
+        // Re-apply collected Symbol properties that the merge dropped.
+        for (const sym of Object.getOwnPropertySymbols(allOfSymbols)) {
+          (resolvedSchema as any)[sym] = allOfSymbols[sym];
+        }
         if (withContainsSchemas.length) {
           resolvedSchema.allOf = withContainsSchemas;
         }
       } catch (e) {
+        // oxlint-disable-next-line no-console
         console.warn('could not merge subschemas in allOf:\n', e);
         const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema;
         return resolvedSchemaWithoutAllOf as S;
@@ -612,18 +666,18 @@ export function retrieveSchemaInternal<
     }
     if (PROPERTIES_KEY in resolvedSchema && PATTERN_PROPERTIES_KEY in resolvedSchema) {
       resolvedSchema = Object.keys(resolvedSchema.properties!).reduce(
-        (schema, key) => {
-          const matchingProperties = getMatchingPatternProperties(schema, key);
+        (acc, key) => {
+          const matchingProperties = getMatchingPatternProperties(acc, key);
           if (!isEmpty(matchingProperties)) {
-            schema.properties[key] = retrieveSchema<T, S, F>(
+            acc.properties[key] = retrieveSchema<T, S, F>(
               validator,
-              { allOf: [schema.properties[key], ...Object.values(matchingProperties)] } as S,
+              { allOf: [acc.properties[key], ...Object.values(matchingProperties)] } as S,
               rootSchema,
               get(rawFormData, [key]) as T,
               experimental_customMergeAllOf,
             );
           }
-          return schema;
+          return acc;
         },
         {
           ...resolvedSchema,
@@ -676,11 +730,7 @@ export function resolveAnyOrOneOfSchemas<
     // Ensure that during expand all branches we pass an object rather than undefined so that all options are interrogated
     const formData = rawFormData === undefined && expandAllBranches ? ({} as T) : rawFormData;
     const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
-    anyOrOneOf = anyOrOneOf.map((s) => {
-      // Due to anyOf/oneOf possibly using the same $ref we always pass a fresh recurse list array so that each option
-      // can resolve recursive references independently
-      return resolveAllReferences(s, rootSchema, []);
-    });
+    anyOrOneOf = anyOrOneOf.map((s) => resolveAllReferences(s, rootSchema, []));
     // Call this to trigger the set of isValid() calls that the schema parser will need
     const option = getFirstMatchingOption<T, S, F>(validator, formData, anyOrOneOf, rootSchema, discriminator);
     if (expandAllBranches) {
@@ -694,7 +744,7 @@ export function resolveAnyOrOneOfSchemas<
       getFirstMatchingOption<T, S, F>(validator, formData, relaxed, rootSchema, discriminator);
       return anyOrOneOf.map((item) => mergeSchemas(remaining, item) as S);
     }
-    schema = mergeSchemas(remaining, anyOrOneOf[option]) as S;
+    return [mergeSchemas(remaining, anyOrOneOf[option]) as S];
   }
   return [schema];
 }
@@ -714,15 +764,15 @@ export function resolveAnyOrOneOfSchemas<
  * @returns - A new array of plain schema objects with `additionalProperties` relaxed where needed
  */
 export function relaxOptionsForScoring<S extends StrictRJSFSchema = RJSFSchema>(
-  options: Array<S | boolean>,
+  options: (S | boolean)[],
   resolveRefs = false,
   rootSchema?: S,
 ): S[] {
   return options.map((d) => {
     if (!isObject(d)) {
-      return (d ? {} : { not: {} }) as S;
+      return normalizeBooleanSchema<S>(d);
     }
-    const schema = resolveRefs && rootSchema ? resolveAllReferences<S>(d as S, rootSchema, []) : (d as S);
+    const schema = resolveRefs && rootSchema ? resolveAllReferences<S>(d, rootSchema, []) : d;
     return schema.additionalProperties === false ? { ...schema, additionalProperties: true } : schema;
   });
 }
@@ -799,45 +849,42 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
   let schemas = [resolvedSchema];
   // Process dependencies updating the local schema properties as appropriate.
   for (const dependencyKey in dependencies) {
-    // Skip this dependency if its trigger property is not present.
-    if (!expandAllBranches && get(formData, [dependencyKey]) === undefined) {
-      continue;
-    }
-    // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.)
-    if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
-      continue;
-    }
-    const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
-      dependencyKey,
-      dependencies as GenericObjectType,
-    );
-    if (Array.isArray(dependencyValue)) {
-      schemas[0] = withDependentProperties<S>(resolvedSchema, dependencyValue);
-    } else if (isObject(dependencyValue)) {
-      schemas = withDependentSchema<T, S, F>(
-        validator,
-        resolvedSchema,
-        rootSchema,
+    if (
+      (expandAllBranches || get(formData, [dependencyKey]) !== undefined) &&
+      (!resolvedSchema.properties || dependencyKey in resolvedSchema.properties)
+    ) {
+      const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
         dependencyKey,
-        dependencyValue as S,
-        expandAllBranches,
-        recurseList,
-        formData,
-        experimental_customMergeAllOf,
+        dependencies as GenericObjectType,
+      );
+      if (Array.isArray(dependencyValue)) {
+        schemas[0] = withDependentProperties<S>(resolvedSchema, dependencyValue);
+      } else if (isObject(dependencyValue)) {
+        schemas = withDependentSchema<T, S, F>(
+          validator,
+          resolvedSchema,
+          rootSchema,
+          dependencyKey,
+          dependencyValue as S,
+          expandAllBranches,
+          recurseList,
+          formData,
+          experimental_customMergeAllOf,
+        );
+      }
+      return schemas.flatMap((schema) =>
+        processDependencies<T, S, F>(
+          validator,
+          remainingDependencies,
+          schema,
+          rootSchema,
+          expandAllBranches,
+          recurseList,
+          formData,
+          experimental_customMergeAllOf,
+        ),
       );
     }
-    return schemas.flatMap((schema) =>
-      processDependencies<T, S, F>(
-        validator,
-        remainingDependencies,
-        schema,
-        rootSchema,
-        expandAllBranches,
-        recurseList,
-        formData,
-        experimental_customMergeAllOf,
-      ),
-    );
   }
   return schemas;
 }
@@ -858,7 +905,7 @@ export function withDependentProperties<S extends StrictRJSFSchema = RJSFSchema>
   const required = Array.isArray(schema.required)
     ? Array.from(new Set([...schema.required, ...additionallyRequired]))
     : additionallyRequired;
-  return { ...schema, required: required };
+  return { ...schema, required };
 }
 
 /** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag
@@ -898,10 +945,10 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
   );
   return dependentSchemas.flatMap((dependent) => {
     const { oneOf, ...dependentSchema } = dependent;
-    schema = mergeSchemas(schema, dependentSchema) as S;
+    const mergedSchema = mergeSchemas(schema, dependentSchema) as S;
     // Since it does not contain oneOf, we return the original schema.
     if (oneOf === undefined) {
-      return schema;
+      return mergedSchema;
     }
     // Resolve $refs inside oneOf.
     const resolvedOneOfs = oneOf.map((subschema) => {
@@ -914,7 +961,7 @@ export function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSc
     return allPermutations.flatMap((resolvedOneOf) =>
       withExactlyOneSubschema<T, S, F>(
         validator,
-        schema,
+        mergedSchema,
         rootSchema,
         dependencyKey,
         resolvedOneOf,
@@ -959,7 +1006,7 @@ export function withExactlyOneSubschema<
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): S[] {
   const validSubschemas = oneOf!.filter((subschema) => {
-    if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
+    if (typeof subschema === 'boolean' || !subschema?.properties) {
       return false;
     }
     const { [dependencyKey]: conditionPropertySchema } = subschema.properties;
@@ -975,7 +1022,8 @@ export function withExactlyOneSubschema<
     return false;
   });
 
-  if (!expandAllBranches && validSubschemas!.length !== 1) {
+  if (!expandAllBranches && validSubschemas.length !== 1) {
+    // oxlint-disable-next-line no-console
     console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid");
     return [schema];
   }
@@ -992,6 +1040,6 @@ export function withExactlyOneSubschema<
       recurseList,
       experimental_customMergeAllOf,
     );
-    return schemas.map((s) => mergeSchemas(schema, s) as S);
+    return schemas.map((resolvedSubschema) => mergeSchemas(schema, resolvedSubschema) as S);
   });
 }

package/src/schema/sanitizeDataForNewSchema.ts

@@ -1,8 +1,9 @@
 import get from 'lodash/get';
 import has from 'lodash/has';
 
-import { PROPERTIES_KEY, REF_KEY } from '../constants';
-import {
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY, REF_KEY } from '../constants';
+import deepEquals from '../deepEquals';
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   GenericObjectType,
@@ -14,6 +15,42 @@ import retrieveSchema from './retrieveSchema';
 
 const NO_VALUE = Symbol('no Value');
 
+function enumValuesForSchema<S extends StrictRJSFSchema = RJSFSchema>(schema: S): any[] | undefined {
+  if (Array.isArray(schema.enum)) {
+    return schema.enum;
+  }
+
+  const options = (schema.oneOf || schema.anyOf) as S[] | undefined;
+  if (!Array.isArray(options)) {
+    return undefined;
+  }
+
+  const values = options
+    .map((option) => {
+      if (CONST_KEY in option) {
+        return option[CONST_KEY];
+      }
+      return Array.isArray(option.enum) && option.enum.length === 1 ? option.enum[0] : NO_VALUE;
+    })
+    .filter((value) => value !== NO_VALUE);
+
+  return values.length > 0 ? values : undefined;
+}
+
+function replacementForInvalidEnumValue<S extends StrictRJSFSchema = RJSFSchema>(schema: S, formValue: any) {
+  const enumValues = enumValuesForSchema(schema);
+  if (!enumValues || enumValues.some((value) => deepEquals(value, formValue))) {
+    return NO_VALUE;
+  }
+
+  const defaultValue = get(schema, DEFAULT_KEY, NO_VALUE);
+  if (defaultValue !== NO_VALUE && enumValues.some((value) => deepEquals(value, defaultValue))) {
+    return defaultValue;
+  }
+
+  return enumValues.length === 1 ? enumValues[0] : undefined;
+}
+
 /** 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 schema
@@ -142,8 +179,8 @@ export default function sanitizeDataForNewSchema<
           // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced
           // with the new default or const. This allows the case where two schemas differ that only by the default/const
           // value to be properly selected
-          const newOptionDefault = get(newKeyedSchema, 'default', NO_VALUE);
-          const oldOptionDefault = get(oldKeyedSchema, 'default', NO_VALUE);
+          const newOptionDefault = get(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
+          const oldOptionDefault = get(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               // If the old default matches the formValue, we'll update the new value to match the new default
@@ -154,18 +191,25 @@ export default function sanitizeDataForNewSchema<
             }
           }
 
-          const newOptionConst = get(newKeyedSchema, 'const', NO_VALUE);
-          const oldOptionConst = get(oldKeyedSchema, 'const', NO_VALUE);
+          const newOptionConst = get(newKeyedSchema, CONST_KEY, NO_VALUE);
+          const oldOptionConst = get(oldKeyedSchema, CONST_KEY, NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined;
           }
+
+          if (has(data, key)) {
+            const enumReplacement = replacementForInvalidEnumValue(newKeyedSchema, formValue);
+            if (enumReplacement !== NO_VALUE) {
+              removeOldSchemaData[key] = enumReplacement;
+            }
+          }
         }
       }
     });
 
     newFormData = {
-      ...(typeof data == 'string' || Array.isArray(data) ? undefined : data),
+      ...(typeof data === 'string' || Array.isArray(data) ? undefined : data),
       ...removeOldSchemaData,
       ...nestedData,
     };
@@ -221,7 +265,12 @@ export default function sanitizeDataForNewSchema<
             return newValue;
           }, []);
         } else {
-          newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data;
+          // Filter out items that are no longer valid in the new items schema (e.g., enum values that changed)
+          const newItemEnumValues = enumValuesForSchema(newSchemaItems as S);
+          const filteredData = newItemEnumValues
+            ? data.filter((item: any) => newItemEnumValues.some((v: any) => deepEquals(v, item)))
+            : data;
+          newFormData = maxItems > 0 && filteredData.length > maxItems ? filteredData.slice(0, maxItems) : filteredData;
         }
       }
     } else if (

package/src/schema/toPathSchema.ts

@@ -1,3 +1,4 @@
+// oxlint-disable typescript/no-deprecated
 import get from 'lodash/get';
 import isObject from 'lodash/isObject';
 import set from 'lodash/set';
@@ -17,7 +18,7 @@ import {
 } from '../constants';
 import deepEquals from '../deepEquals';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import {
+import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   GenericObjectType,
@@ -51,16 +52,16 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): PathSchema<T> {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
-    const _schema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+    const innerSchema = retrieveSchema<T, S, F>(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, innerSchema));
     if (sameSchemaIndex === -1) {
       return toPathSchemaInternal<T, S, F>(
         validator,
-        _schema,
+        innerSchema,
         name,
         rootSchema,
         formData,
-        _recurseList.concat(_schema),
+        _recurseList.concat(innerSchema),
         experimental_customMergeAllOf,
       );
     }
@@ -82,12 +83,12 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
       discriminator,
       experimental_customMergeAllOf,
     );
-    const _schema: S = xxxOf![index] as S;
+    const innerSchema: S = xxxOf[index];
     pathSchema = {
       ...pathSchema,
       ...toPathSchemaInternal<T, S, F>(
         validator,
-        _schema,
+        innerSchema,
         name,
         rootSchema,
         formData,
@@ -144,6 +145,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
             experimental_customMergeAllOf,
           );
         } else {
+          // oxlint-disable-next-line no-console
           console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
         }
       });
@@ -161,6 +163,8 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
       });
     }
   } else if (PROPERTIES_KEY in schema) {
+    // This is a deprecated function that is no longer used by RJSF
+    // oxlint-disable-next-line guard-for-in
     for (const property in schema.properties) {
       const field: S = get(schema, [PROPERTIES_KEY, property], {}) as S;
       (pathSchema as PathSchema<GenericObjectType>)[property] = toPathSchemaInternal<T, S, F>(

package/src/schemaRequiresTrueValue.ts

@@ -1,4 +1,4 @@
-import { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types';
 
 /** Check to see if a `schema` specifies that a value must be true. This happens when:
  * - `schema.const` is truthy
@@ -16,17 +16,17 @@ export default function schemaRequiresTrueValue<S extends StrictRJSFSchema = RJS
   }
 
   // Check if an enum has a single value of true
-  if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
+  if (schema.enum?.length === 1 && schema.enum[0] === true) {
     return true;
   }
 
   // If anyOf has a single value, evaluate the subschema
-  if (schema.anyOf && schema.anyOf.length === 1) {
+  if (schema.anyOf?.length === 1) {
     return schemaRequiresTrueValue(schema.anyOf[0] as S);
   }
 
   // If oneOf has a single value, evaluate the subschema
-  if (schema.oneOf && schema.oneOf.length === 1) {
+  if (schema.oneOf?.length === 1) {
     return schemaRequiresTrueValue(schema.oneOf[0] as S);
   }