@rjsf/utils 6.8.0 → 6.10.0

package/src/schema/findFieldInSchema.ts

@@ -1,7 +1,5 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-
-import { ANY_OF_KEY, ONE_OF_KEY, PROPERTIES_KEY, REQUIRED_KEY } from '../constants';
+import { ANY_OF_KEY, ONE_OF_KEY, PROPERTIES_KEY, REQUIRED_KEY } from '../constants.ts';
+import { getByPath, hasByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -10,9 +8,9 @@ import type {
   SchemaFieldPath,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf';
-import getFromSchema from './getFromSchema';
+} from '../types.ts';
+import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf.ts';
+import getFromSchema from './getFromSchema.ts';
 
 /** Unique schema that represents no schema was found, exported for testing purposes */
 export const NOT_FOUND_SCHEMA = { title: '!@#$_UNKNOWN_$#@!' };
@@ -60,7 +58,7 @@ export default function findFieldInSchema<
         {} as S,
         experimental_customMergeAllOf,
       );
-      if (has(parentField, ONE_OF_KEY)) {
+      if (hasByPath(parentField, ONE_OF_KEY)) {
         // if this sub-path has a `oneOf` then use the formData to drill into the schema with the selected option
         parentField = findSelectedOptionInXxxOf(
           validator,
@@ -68,10 +66,10 @@ export default function findFieldInSchema<
           parentField,
           fieldNameKey,
           ONE_OF_KEY,
-          get(formData, subPath),
+          getByPath<T>(formData, subPath),
           experimental_customMergeAllOf,
         )!;
-      } else if (has(parentField, ANY_OF_KEY)) {
+      } else if (hasByPath(parentField, ANY_OF_KEY)) {
         // if this sub-path has a `anyOf` then use the formData to drill into the schema with the selected option
         parentField = findSelectedOptionInXxxOf(
           validator,
@@ -79,14 +77,14 @@ export default function findFieldInSchema<
           parentField,
           fieldNameKey,
           ANY_OF_KEY,
-          get(formData, subPath),
+          getByPath<T>(formData, subPath),
           experimental_customMergeAllOf,
         )!;
       }
     });
   }
 
-  if (has(parentField, ONE_OF_KEY)) {
+  if (hasByPath(parentField, ONE_OF_KEY)) {
     // When oneOf is in the root schema, use the formData to drill into the schema with the selected option
     parentField = findSelectedOptionInXxxOf(
       validator,
@@ -97,7 +95,7 @@ export default function findFieldInSchema<
       formData,
       experimental_customMergeAllOf,
     )!;
-  } else if (has(parentField, ANY_OF_KEY)) {
+  } else if (hasByPath(parentField, ANY_OF_KEY)) {
     // When anyOf is in the root schema, use the formData to drill into the schema with the selected option
     parentField = findSelectedOptionInXxxOf(
       validator,

package/src/schema/findSelectedOptionInXxxOf.ts

@@ -1,16 +1,15 @@
-import get from 'lodash/get';
-
-import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from '../constants';
-import deepEquals from '../deepEquals';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import { getByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
 /** Finds the option inside the `schema['any/oneOf']` list which has the `properties[selectorField].default` or
  * `properties[selectorField].const` that matches the `formData[selectorField]` value. For the purposes of this
@@ -45,14 +44,14 @@ export default function findSelectedOptionInXxxOf<
     const xxxOfs = schema[xxx].map((xxxOf) =>
       retrieveSchema<T, S, F>(validator, xxxOf as S, rootSchema, formData, experimental_customMergeAllOf),
     );
-    const data = get(formData, selectorField);
+    const data = getByPath(formData, selectorField);
     if (data !== undefined) {
       return xxxOfs.find((xxxOfOption) =>
         deepEquals(
-          get(
+          getByPath(
             xxxOfOption,
             [PROPERTIES_KEY, selectorField, DEFAULT_KEY],
-            get(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY]),
+            getByPath(xxxOfOption, [PROPERTIES_KEY, selectorField, CONST_KEY]),
           ),
           data,
         ),

package/src/schema/getClosestMatchingOption.ts

@@ -1,24 +1,18 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-import isNumber from 'lodash/isNumber';
-import isObject from 'lodash/isObject';
-import isString from 'lodash/isString';
-import reduce from 'lodash/reduce';
-import times from 'lodash/times';
-
-import { ONE_OF_KEY, REF_KEY, JUNK_OPTION_ID, ANY_OF_KEY } from '../constants';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
-import guessType from '../guessType';
+import { ONE_OF_KEY, REF_KEY, JUNK_OPTION_ID, ANY_OF_KEY } from '../constants.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator.ts';
+import guessType from '../guessType.ts';
+import isObject from '../isObject.ts';
+import { getByPath, hasByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import getFirstMatchingOption from './getFirstMatchingOption';
-import retrieveSchema, { resolveAllReferences } from './retrieveSchema';
+} from '../types.ts';
+import getFirstMatchingOption from './getFirstMatchingOption.ts';
+import retrieveSchema, { resolveAllReferences } from './retrieveSchema.ts';
 
 /** A junk option used to determine when the getFirstMatchingOption call really matches an option rather than returning
  * the first item
@@ -64,77 +58,73 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
   let totalScore = 0;
   if (schema) {
     if (isObject(schema.properties)) {
-      totalScore += reduce(
-        schema.properties,
-        (score, value, key) => {
-          const formValue = get(formData, key);
-          if (typeof value === 'boolean') {
-            return score;
-          }
-          if (has(value, REF_KEY)) {
-            const newSchema = retrieveSchema<T, S, F>(
+      totalScore += Object.entries(schema.properties).reduce((score, [key, value]) => {
+        const formValue = formData?.[key];
+        if (typeof value === 'boolean') {
+          return score;
+        }
+        if (hasByPath(value, REF_KEY)) {
+          const newSchema = retrieveSchema<T, S, F>(
+            validator,
+            value as S,
+            rootSchema,
+            formValue,
+            experimental_customMergeAllOf,
+          );
+          return (
+            score +
+            calculateIndexScore<T, S, F>(
+              validator,
+              rootSchema,
+              newSchema,
+              formValue || {},
+              experimental_customMergeAllOf,
+            )
+          );
+        }
+        if ((hasByPath(value, ONE_OF_KEY) || hasByPath(value, ANY_OF_KEY)) && formValue) {
+          const xxxOfKey = hasByPath(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+          const discriminator = getDiscriminatorFieldFromSchema<S>(value as S);
+          return (
+            score +
+            getClosestMatchingOption<T, S, F>(
               validator,
-              value as S,
               rootSchema,
               formValue,
+              getByPath<S[]>(value, xxxOfKey),
+              -1,
+              discriminator,
               experimental_customMergeAllOf,
-            );
-            return (
-              score +
-              calculateIndexScore<T, S, F>(
-                validator,
-                rootSchema,
-                newSchema,
-                formValue || {},
-                experimental_customMergeAllOf,
-              )
-            );
-          }
-          if ((has(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
-            const xxxOfKey = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-            const discriminator = getDiscriminatorFieldFromSchema<S>(value as S);
-            return (
-              score +
-              getClosestMatchingOption<T, S, F>(
-                validator,
-                rootSchema,
-                formValue,
-                get(value, xxxOfKey) as S[],
-                -1,
-                discriminator,
-                experimental_customMergeAllOf,
-              )
-            );
-          }
-          if (value.type === 'object') {
-            // If the structure is matching then give it a little boost in score
-            const structureBoost = isObject(formValue) ? 1 : 0;
-            return (
-              score +
-              structureBoost +
-              calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue, experimental_customMergeAllOf)
-            );
+            )
+          );
+        }
+        if (value.type === 'object') {
+          // If the structure is matching then give it a little boost in score
+          const structureBoost = typeof formValue === 'object' && formValue !== null ? 1 : 0;
+          return (
+            score +
+            structureBoost +
+            calculateIndexScore<T, S, F>(validator, rootSchema, value as S, formValue, experimental_customMergeAllOf)
+          );
+        }
+        if (value.type === guessType(formValue)) {
+          // If the types match, then we bump the score by one
+          let newScore = score + 1;
+          if (value.default) {
+            // If the schema contains a readonly default value score the value that matches the default higher and
+            // any non-matching value lower
+            newScore += formValue === value.default ? 1 : -1;
+          } else if (value.const) {
+            // If the schema contains a const value score the value that matches the default higher and
+            // any non-matching value lower
+            newScore += formValue === value.const ? 1 : -1;
           }
-          if (value.type === guessType(formValue)) {
-            // If the types match, then we bump the score by one
-            let newScore = score + 1;
-            if (value.default) {
-              // If the schema contains a readonly default value score the value that matches the default higher and
-              // any non-matching value lower
-              newScore += formValue === value.default ? 1 : -1;
-            } else if (value.const) {
-              // If the schema contains a const value score the value that matches the default higher and
-              // any non-matching value lower
-              newScore += formValue === value.const ? 1 : -1;
-            }
-            // TODO eventually, deal with enums/arrays
-            return newScore;
-          }
-          return score;
-        },
-        0,
-      );
-    } else if (isString(schema.type) && schema.type === guessType(formData)) {
+          // TODO eventually, deal with enums/arrays
+          return newScore;
+        }
+        return score;
+      }, 0);
+    } else if (typeof schema.type === 'string' && schema.type === guessType(formData)) {
       totalScore += 1;
     }
   }
@@ -181,7 +171,7 @@ export default function getClosestMatchingOption<
   const resolvedOptions = options.map((option) => resolveAllReferences<S>(option, rootSchema, []));
 
   const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-  if (isNumber(simpleDiscriminatorMatch)) {
+  if (typeof simpleDiscriminatorMatch === 'number') {
     return simpleDiscriminatorMatch;
   }
 
@@ -202,7 +192,7 @@ export default function getClosestMatchingOption<
   }
   if (!allValidIndexes.length) {
     // No indexes were valid, so we'll score all the options, add all the indexes
-    times(resolvedOptions.length, (i) => allValidIndexes.push(i));
+    allValidIndexes.push(...resolvedOptions.keys());
   }
   interface BestType {
     bestIndex: number;

package/src/schema/getDefaultFormState.ts

@@ -1,6 +1,4 @@
 import type { JSONSchema7Object } from 'json-schema';
-import get from 'lodash/get';
-import isEmpty from 'lodash/isEmpty';
 
 import {
   ALL_OF_KEY,
@@ -10,21 +8,22 @@ import {
   DEPENDENCIES_KEY,
   IF_KEY,
   ONE_OF_KEY,
-  PROPERTIES_KEY,
   REF_KEY,
-} from '../constants';
-import constIsAjvDataReference from '../constIsAjvDataReference';
-import deepEquals from '../deepEquals';
-import findSchemaDefinition from '../findSchemaDefinition';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import getSchemaType from '../getSchemaType';
-import isConstant from '../isConstant';
-import isFixedItems from '../isFixedItems';
-import isObject from '../isObject';
-import mergeDefaultsWithFormData from '../mergeDefaultsWithFormData';
-import mergeObjects from '../mergeObjects';
-import mergeSchemas from '../mergeSchemas';
-import optionsList from '../optionsList';
+} from '../constants.ts';
+import constIsAjvDataReference from '../constIsAjvDataReference.ts';
+import deepEquals from '../deepEquals.ts';
+import findSchemaDefinition from '../findSchemaDefinition.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import getPropertySchema from '../getPropertySchema.ts';
+import getSchemaType from '../getSchemaType.ts';
+import isConstant from '../isConstant.ts';
+import isFixedItems from '../isFixedItems.ts';
+import isObject from '../isObject.ts';
+import mergeDefaultsWithFormData from '../mergeDefaultsWithFormData.ts';
+import mergeObjects from '../mergeObjects.ts';
+import mergeSchemas from '../mergeSchemas.ts';
+import optionsList from '../optionsList.ts';
+import { getByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   Experimental_DefaultFormStateBehavior,
@@ -33,11 +32,11 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import getClosestMatchingOption from './getClosestMatchingOption';
-import isMultiSelect from './isMultiSelect';
-import isSelect from './isSelect';
-import retrieveSchema, { resolveDependencies } from './retrieveSchema';
+} from '../types.ts';
+import getClosestMatchingOption from './getClosestMatchingOption.ts';
+import isMultiSelect from './isMultiSelect.ts';
+import isSelect from './isSelect.ts';
+import retrieveSchema, { resolveDependencies } from './retrieveSchema.ts';
 
 const PRIMITIVE_TYPES = ['string', 'number', 'integer', 'boolean', 'null'];
 
@@ -85,6 +84,22 @@ export function getInnerSchemaForArrayItem<S extends StrictRJSFSchema = RJSFSche
   return {} as S;
 }
 
+/** Determines whether `value` holds anything: a non-empty string or array, or an object with at least one own key.
+ * Everything else — including numbers, booleans, `null` and `undefined` — has no content.
+ *
+ * @param value - The value to inspect
+ * @returns - True if the value holds content, otherwise false
+ */
+function hasContent(value: unknown): boolean {
+  if (typeof value === 'string' || Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === 'object' && value !== null) {
+    return Object.keys(value).length > 0;
+  }
+  return false;
+}
+
 /** Checks if the given `schema` contains the `null` type along with another type AND if the `default` contained within
  * the schema is `null` AND the `computedDefault` is empty. If all of those conditions are true, then the `schema`'s
  * default should be `null` rather than `computedDefault`.
@@ -99,7 +114,7 @@ export function computeDefaultBasedOnSchemaTypeAndDefaults<T = any, S extends St
 ) {
   const { default: schemaDefault, type } = schema;
   const shouldReturnNullAsDefault =
-    Array.isArray(type) && type.includes('null') && isEmpty(computedDefault) && schemaDefault === null;
+    Array.isArray(type) && type.includes('null') && !hasContent(computedDefault) && schemaDefault === null;
   return shouldReturnNullAsDefault ? (null as T) : computedDefault;
 }
 
@@ -144,7 +159,11 @@ function maybeAddDefaultToObject<T = any>(
   } else if (includeUndefinedValues === 'excludeObjectChildren') {
     // Fix for Issue #4709: When in 'excludeObjectChildren' mode, don't set primitive fields to empty objects
     // Only add the computed default if it's not an empty object placeholder for a primitive field
-    if ((isNullType && computedDefault !== undefined) || !isObject(computedDefault) || !isEmpty(computedDefault)) {
+    if (
+      (isNullType && computedDefault !== undefined) ||
+      !isObject(computedDefault) ||
+      Object.keys(computedDefault).length > 0
+    ) {
       acc[key] = computedDefault;
     }
     // If computedDefault is an empty object {}, don't add it - let the field stay undefined
@@ -156,14 +175,14 @@ function maybeAddDefaultToObject<T = any>(
     if (isObject(computedDefault)) {
       // If emptyObjectFields 'skipEmptyDefaults' store computedDefault if it's a non-empty object(e.g. not {})
       if (emptyObjectFields === 'skipEmptyDefaults') {
-        if (!isEmpty(computedDefault)) {
+        if (Object.keys(computedDefault).length > 0) {
           acc[key] = computedDefault;
         }
       } // Else store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions
       // Condition 1: If computedDefault is not empty or if the key is a required field
       // Condition 2: If the parent object is required or emptyObjectFields is not 'populateRequiredDefaults'
       else if (
-        (!isEmpty(computedDefault) || requiredFields.includes(key)) &&
+        (Object.keys(computedDefault).length > 0 || requiredFields.includes(key)) &&
         (isSelfOrParentRequired || emptyObjectFields !== 'populateRequiredDefaults')
       ) {
         acc[key] = computedDefault;
@@ -293,7 +312,8 @@ export function computeDefaults<T = any, S extends StrictRJSFSchema = RJSFSchema
     // Then set the defaults from the current schema for the referenced schema.
     // Only do this if rawFormData has no meaningful data - we don't want to override user's existing values.
     // Check for undefined OR empty object - rawFormData may be coerced to {} when not an object.
-    const hasNoExistingData = rawFormData === undefined || (isObject(rawFormData) && isEmpty(rawFormData));
+    const hasNoExistingData =
+      rawFormData === undefined || (isObject(rawFormData) && Object.keys(rawFormData).length === 0);
     if (schemaToCompute && !defaults && hasNoExistingData) {
       defaults = schema.default as T | undefined;
     }
@@ -483,13 +503,13 @@ export function ensureFormDataMatchingSchema<
   } else if (isObject(validFormData) && isObject(schemaToMatch.properties)) {
     validFormData = Object.keys(schemaToMatch.properties).reduce(
       (acc: GenericObjectType, key: string) => {
-        const propertySchema: S = get(schemaToMatch, [PROPERTIES_KEY, key], {}) as S;
+        const propertySchema = getPropertySchema<S>(schemaToMatch, key);
         if (key in acc && (shouldRetrieveAllOf || (isObject(propertySchema) && ALL_OF_KEY in propertySchema))) {
           acc[key] = ensureFormDataMatchingSchema<T, S, F>(
             validator,
             propertySchema,
             rootSchema,
-            get(acc, key),
+            acc[key],
             experimental_defaultFormStateBehavior,
             experimental_customMergeAllOf,
           );
@@ -543,7 +563,7 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc: GenericObjectType, key: string) => {
-        const propertySchema: S = get(retrievedSchema, [PROPERTIES_KEY, key], {}) as S;
+        const propertySchema = getPropertySchema<S>(retrievedSchema, key);
         // Check if the parent schema has a const property defined AND we are supporting const as defaults, then we
         // should always return the computedDefault since it's coming from the const.
         const hasParentConst = isObject(parentConst) && (parentConst as JSONSchema7Object)[key] !== undefined;
@@ -559,8 +579,8 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get(defaults, [key]),
-          rawFormData: get(formData, [key]),
+          parentDefaults: getByPath<T>(defaults, key),
+          rawFormData: getByPath<T>(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated,
@@ -611,8 +631,8 @@ export function getObjectDefaults<T = any, S extends StrictRJSFSchema = RJSFSche
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           includeUndefinedValues: includeUndefinedValues === true,
-          parentDefaults: get(defaults, [key]),
-          rawFormData: get(formData, [key]),
+          parentDefaults: getByPath<T>(defaults, key),
+          rawFormData: getByPath<T>(formData, key),
           required: retrievedSchema.required?.includes(key),
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated,
@@ -702,7 +722,7 @@ export function getArrayDefaults<T = any, S extends StrictRJSFSchema = RJSFSchem
           experimental_defaultFormStateBehavior,
           experimental_customMergeAllOf,
           rawFormData: item,
-          parentDefaults: get(defaults, [idx]),
+          parentDefaults: getByPath<T>(defaults, idx),
           required,
           shouldMergeDefaultsIntoFormData,
           initialDefaultsGenerated,
@@ -792,6 +812,14 @@ export function getDefaultBasedOnSchemaType<
     case 'array': {
       return getArrayDefaults(validator, rawSchema, computeDefaultsProps, defaults as T[]);
     }
+    case 'boolean': {
+      // A required boolean with no explicit default gets false — it must be
+      // present in the submitted data, and false is the natural zero-value.
+      if (computeDefaultsProps.required && defaults === undefined) {
+        return false as unknown as T;
+      }
+      return undefined;
+    }
     default:
       return undefined;
   }

package/src/schema/getDisplayLabel.ts

@@ -1,7 +1,7 @@
-import { ADDITIONAL_PROPERTY_FLAG, UI_FIELD_KEY, UI_WIDGET_KEY } from '../constants';
-import getSchemaType from '../getSchemaType';
-import getUiOptions from '../getUiOptions';
-import isCustomWidget from '../isCustomWidget';
+import { ADDITIONAL_PROPERTY_FLAG, UI_FIELD_KEY, UI_WIDGET_KEY } from '../constants.ts';
+import getSchemaType from '../getSchemaType.ts';
+import getUiOptions from '../getUiOptions.ts';
+import isCustomWidget from '../isCustomWidget.ts';
 import type {
   FormContextType,
   GlobalUISchemaOptions,
@@ -11,9 +11,9 @@ import type {
   UiSchema,
   ValidatorType,
   Experimental_CustomMergeAllOf,
-} from '../types';
-import isFilesArray from './isFilesArray';
-import isMultiSelect from './isMultiSelect';
+} from '../types.ts';
+import isFilesArray from './isFilesArray.ts';
+import isMultiSelect from './isMultiSelect.ts';
 
 /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
  * should be displayed in a UI.

package/src/schema/getFirstMatchingOption.ts

@@ -1,10 +1,7 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-import isNumber from 'lodash/isNumber';
-
-import { PROPERTIES_KEY } from '../constants';
-import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator';
-import type { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+import { PROPERTIES_KEY } from '../constants.ts';
+import getOptionMatchingSimpleDiscriminator from '../getOptionMatchingSimpleDiscriminator.ts';
+import { getByPath } from '../pathUtils.ts';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types.ts';
 
 /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
  * Always returns the first option if there is nothing that matches.
@@ -35,7 +32,7 @@ export default function getFirstMatchingOption<
   }
 
   const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField);
-  if (isNumber(simpleDiscriminatorMatch)) {
+  if (typeof simpleDiscriminatorMatch === 'number') {
     return simpleDiscriminatorMatch;
   }
 
@@ -43,9 +40,11 @@ export default function getFirstMatchingOption<
     const option = options[i];
 
     // If we have a discriminator field, then we will use this to make the determination
-    if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
-      const value = get(formData, discriminatorField);
-      const discriminator: S = get(option, [PROPERTIES_KEY, discriminatorField], {}) as S;
+    const discriminator = discriminatorField
+      ? (option[PROPERTIES_KEY]?.[discriminatorField] as S | undefined)
+      : undefined;
+    if (discriminatorField && discriminator !== undefined) {
+      const value = getByPath<T>(formData, discriminatorField);
       if (validator.isValid(discriminator, value, rootSchema)) {
         return i;
       }

package/src/schema/getFromSchema.ts

@@ -1,8 +1,5 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-import isEmpty from 'lodash/isEmpty';
-
-import { REF_KEY } from '../constants';
+import { REF_KEY } from '../constants.ts';
+import { getByPath, hasByPath, toPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -10,10 +7,10 @@ import type {
   SchemaFieldPath,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
-/** Internal helper function that acts like lodash's `get` but additionally retrieves `$ref`s as needed to get the path
+/** Internal helper function that acts like `getByPath` but additionally retrieves `$ref`s as needed to get the path
  * for schemas containing potentially nested `$ref`s.
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
@@ -31,16 +28,17 @@ function getFromSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   experimental_customMergeAllOf?: Experimental_CustomMergeAllOf<S>,
 ): T | S | undefined {
   let fieldSchema = schema;
-  if (has(schema, REF_KEY)) {
+  // hasByPath instead of `in` because `schema` can be undefined at runtime when drilling past a non-matching xxxOf
+  if (hasByPath(schema, REF_KEY)) {
     fieldSchema = retrieveSchema<T, S, F>(validator, schema, rootSchema, undefined, experimental_customMergeAllOf);
   }
-  if (isEmpty(path)) {
+  if (path.length === 0) {
     return fieldSchema;
   }
-  const pathList = Array.isArray(path) ? [...path] : path.split('.');
+  const pathList = Array.isArray(path) ? [...path] : toPath(path);
   const [part, ...nestedPath] = pathList;
-  if (part !== undefined && part !== '' && has(fieldSchema, part)) {
-    fieldSchema = get(fieldSchema, part) as S;
+  if (part !== undefined && part !== '' && hasByPath(fieldSchema, part)) {
+    fieldSchema = getByPath<S>(fieldSchema, part);
     return getFromSchemaInternal<T, S, F>(
       validator,
       rootSchema,
@@ -52,7 +50,7 @@ function getFromSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   return undefined;
 }
 
-/** Helper that acts like lodash's `get` but additionally retrieves `$ref`s as needed to get the path for schemas
+/** Helper that acts like `getByPath` but additionally retrieves `$ref`s as needed to get the path for schemas
  * containing potentially nested `$ref`s.
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs