@rjsf/utils 6.7.1 → 6.10.0

package/src/index.ts

@@ -1,39 +1,40 @@
-import allowAdditionalItems from './allowAdditionalItems';
-import asNumber from './asNumber';
-import canExpand from './canExpand';
-import createErrorHandler from './createErrorHandler';
-import createSchemaUtils from './createSchemaUtils';
-import dataURItoBlob from './dataURItoBlob';
-import dateRangeOptions from './dateRangeOptions';
-import deepEquals from './deepEquals';
-import englishStringTranslator from './englishStringTranslator';
-import enumOptionsDeselectValue from './enumOptionsDeselectValue';
-import enumOptionSelectedValue from './enumOptionSelectedValue';
-import enumOptionsIndexForValue from './enumOptionsIndexForValue';
-import enumOptionsIsSelected from './enumOptionsIsSelected';
-import enumOptionsSelectValue from './enumOptionsSelectValue';
-import enumOptionsValueForIndex from './enumOptionsValueForIndex';
-import enumOptionValueDecoder from './enumOptionValueDecoder';
-import enumOptionValueEncoder from './enumOptionValueEncoder';
-import ErrorSchemaBuilder from './ErrorSchemaBuilder';
-import findSchemaDefinition from './findSchemaDefinition';
-import getChangedFields from './getChangedFields';
-import type { DateElementFormat, DateElementProp } from './getDateElementProps';
-import getDateElementProps from './getDateElementProps';
-import getDecimalSeparator from './getDecimalSeparator';
-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';
-import getTestIds from './getTestIds';
-import getUiOptions from './getUiOptions';
-import getWidget from './getWidget';
-import guessType from './guessType';
-import hashForSchema, { hashObject, hashString, sortedJSONStringify } from './hashForSchema';
-import hasWidget from './hasWidget';
+import allowAdditionalItems from './allowAdditionalItems.ts';
+import asNumber from './asNumber.ts';
+import canExpand from './canExpand.ts';
+import createErrorHandler from './createErrorHandler.ts';
+import createSchemaUtils from './createSchemaUtils.ts';
+import dataURItoBlob from './dataURItoBlob.ts';
+import dateRangeOptions from './dateRangeOptions.ts';
+import deepEquals from './deepEquals.ts';
+import englishStringTranslator from './englishStringTranslator.ts';
+import enumOptionsDeselectValue from './enumOptionsDeselectValue.ts';
+import enumOptionSelectedValue from './enumOptionSelectedValue.ts';
+import enumOptionsIndexForValue from './enumOptionsIndexForValue.ts';
+import enumOptionsIsSelected from './enumOptionsIsSelected.ts';
+import enumOptionsSelectValue from './enumOptionsSelectValue.ts';
+import enumOptionsValueForIndex from './enumOptionsValueForIndex.ts';
+import enumOptionValueDecoder from './enumOptionValueDecoder.ts';
+import enumOptionValueEncoder from './enumOptionValueEncoder.ts';
+import ErrorSchemaBuilder from './ErrorSchemaBuilder.ts';
+import findSchemaDefinition from './findSchemaDefinition.ts';
+import getChangedFields from './getChangedFields.ts';
+import type { DateElementFormat, DateElementProp } from './getDateElementProps.ts';
+import getDateElementProps from './getDateElementProps.ts';
+import getDecimalSeparator from './getDecimalSeparator.ts';
+import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema.ts';
+import getInputProps from './getInputProps.ts';
+import getOptionMatchingSimpleDiscriminator from './getOptionMatchingSimpleDiscriminator.ts';
+import getOptionValueFormat from './getOptionValueFormat.ts';
+import getPropertySchema from './getPropertySchema.ts';
+import getSchemaType from './getSchemaType.ts';
+import getSubmitButtonOptions from './getSubmitButtonOptions.ts';
+import getTemplate from './getTemplate.ts';
+import getTestIds from './getTestIds.ts';
+import getUiOptions from './getUiOptions.ts';
+import getWidget from './getWidget.tsx';
+import guessType from './guessType.ts';
+import hashForSchema, { hashObject, hashString, sortedJSONStringify } from './hashForSchema.ts';
+import hasWidget from './hasWidget.ts';
 import {
   ariaDescribedByIds,
   buttonId,
@@ -44,57 +45,61 @@ import {
   optionalControlsId,
   optionId,
   titleId,
-} from './idGenerators';
-import isConstant from './isConstant';
-import isCustomWidget from './isCustomWidget';
-import isFixedItems from './isFixedItems';
-import isFormDataAvailable from './isFormDataAvailable';
-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';
-import mergeSchemas from './mergeSchemas';
-import { bracketNameGenerator, dotNotationNameGenerator } from './nameGenerators';
-import optionsList from './optionsList';
-import orderProperties from './orderProperties';
-import pad from './pad';
-import parseDateString from './parseDateString';
-import rangeSpec from './rangeSpec';
-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 type { ComponentUpdateStrategy } from './shouldRender';
-import shouldRender from './shouldRender';
-import shouldRenderOptionalField from './shouldRenderOptionalField';
-import toConstant from './toConstant';
-import toDateString from './toDateString';
-import toErrorList from './toErrorList';
-import toErrorSchema from './toErrorSchema';
-import toFieldPathId from './toFieldPathId';
-import unwrapErrorHandler from './unwrapErrorHandler';
-import type { DateElementProps, UseAltDateWidgetResult } from './useAltDateWidgetProps';
-import useAltDateWidgetProps, { DateElement } from './useAltDateWidgetProps';
-import useDeepCompareMemo from './useDeepCompareMemo';
-import type { FileInfoType, UseFileWidgetPropsResult } from './useFileWidgetProps';
-import useFileWidgetProps from './useFileWidgetProps';
-import utcToLocal from './utcToLocal';
-import validationDataMerge from './validationDataMerge';
-import withIdRefPrefix from './withIdRefPrefix';
+} from './idGenerators.ts';
+import isConstant from './isConstant.ts';
+import isCustomWidget from './isCustomWidget.ts';
+import isFixedItems from './isFixedItems.ts';
+import isFormDataAvailable from './isFormDataAvailable.ts';
+import isObject from './isObject.ts';
+import isPlainObject from './isPlainObject.ts';
+import isRootSchema from './isRootSchema.ts';
+import labelValue from './labelValue.ts';
+import localToUTC from './localToUTC.ts';
+import logUnsupportedDefaultForEnum from './logUnsupportedDefaultForEnum.ts';
+import lookupFromFormContext from './lookupFromFormContext.ts';
+import mergeDefaultsWithFormData from './mergeDefaultsWithFormData.ts';
+import mergeObjects from './mergeObjects.ts';
+import mergeSchemas from './mergeSchemas.ts';
+import { bracketNameGenerator, dotNotationNameGenerator } from './nameGenerators.ts';
+import noop from './noop.ts';
+import optionsList from './optionsList.ts';
+import orderProperties from './orderProperties.ts';
+import pad from './pad.ts';
+import parseDateString from './parseDateString.ts';
+import { getByPath, hasByPath, setByPath, toPath, unsetByPath } from './pathUtils.ts';
+import type { ObjectPath } from './pathUtils.ts';
+import rangeSpec from './rangeSpec.ts';
+import removeOptionalEmptyObjects from './removeOptionalEmptyObjects.ts';
+import replaceStringParameters from './replaceStringParameters.ts';
+import resolveUiSchema from './resolveUiSchema.ts';
+import schemaRequiresTrueValue from './schemaRequiresTrueValue.ts';
+import SelectedOptionDescription from './SelectedOptionDescription.tsx';
+import type { SelectedOptionDescriptionProps } from './SelectedOptionDescription.tsx';
+import shallowEquals from './shallowEquals.ts';
+import type { ComponentUpdateStrategy } from './shouldRender.ts';
+import shouldRender from './shouldRender.ts';
+import shouldRenderOptionalField from './shouldRenderOptionalField.ts';
+import toConstant from './toConstant.ts';
+import toDateString from './toDateString.ts';
+import toErrorList from './toErrorList.ts';
+import toErrorSchema from './toErrorSchema.ts';
+import toFieldPathId from './toFieldPathId.ts';
+import unwrapErrorHandler from './unwrapErrorHandler.ts';
+import type { DateElementProps, UseAltDateWidgetResult } from './useAltDateWidgetProps.tsx';
+import useAltDateWidgetProps, { DateElement } from './useAltDateWidgetProps.tsx';
+import useDeepCompareMemo from './useDeepCompareMemo.ts';
+import type { FileInfoType, UseFileWidgetPropsResult } from './useFileWidgetProps.ts';
+import useFileWidgetProps from './useFileWidgetProps.ts';
+import utcToLocal from './utcToLocal.ts';
+import validationDataMerge from './validationDataMerge.ts';
+import withIdRefPrefix from './withIdRefPrefix.ts';
 
-export type * from './types';
-export * from './enums';
+export type * from './types.ts';
+export * from './enums.ts';
 
-export * from './constants';
-export * from './parser';
-export * from './schema';
+export * from './constants.ts';
+export * from './parser/index.ts';
+export * from './schema/index.ts';
 
 export type {
   ComponentUpdateStrategy,
@@ -102,6 +107,7 @@ export type {
   DateElementProp,
   DateElementProps,
   FileInfoType,
+  ObjectPath,
   SelectedOptionDescriptionProps,
   UseAltDateWidgetResult,
   UseFileWidgetPropsResult,
@@ -139,14 +145,17 @@ export {
   getDiscriminatorFieldFromSchema,
   getInputProps,
   getOptionMatchingSimpleDiscriminator,
+  getPropertySchema,
   getOptionValueFormat,
   getSchemaType,
+  getByPath,
   getSubmitButtonOptions,
   getTemplate,
   getTestIds,
   getUiOptions,
   getWidget,
   guessType,
+  hasByPath,
   hasWidget,
   hashForSchema,
   hashObject,
@@ -157,6 +166,7 @@ export {
   isFixedItems,
   isFormDataAvailable,
   isObject,
+  isPlainObject,
   isRootSchema,
   labelValue,
   localToUTC,
@@ -165,6 +175,7 @@ export {
   mergeDefaultsWithFormData,
   mergeObjects,
   mergeSchemas,
+  noop,
   optionalControlsId,
   optionId,
   optionsList,
@@ -177,6 +188,7 @@ export {
   replaceStringParameters,
   resolveUiSchema,
   schemaRequiresTrueValue,
+  setByPath,
   SelectedOptionDescription,
   shallowEquals,
   shouldRender,
@@ -188,6 +200,8 @@ export {
   toErrorList,
   toErrorSchema,
   toFieldPathId,
+  toPath,
+  unsetByPath,
   unwrapErrorHandler,
   useAltDateWidgetProps,
   useDeepCompareMemo,

package/src/isConstant.ts

@@ -1,5 +1,5 @@
-import { CONST_KEY } from './constants';
-import type { RJSFSchema, StrictRJSFSchema } from './types';
+import { CONST_KEY } from './constants.ts';
+import type { RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** 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 type { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import getUiOptions from './getUiOptions.ts';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema } from './types.ts';
 
 /** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden`
  *

package/src/isFixedItems.ts

@@ -1,5 +1,5 @@
-import isObject from './isObject';
-import type { RJSFSchema, StrictRJSFSchema } from './types';
+import isObject from './isObject.ts';
+import type { RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is an array that only
  * contains objects.

package/src/isFormDataAvailable.ts

@@ -1,7 +1,3 @@
-import isEmpty from 'lodash/isEmpty';
-import isNil from 'lodash/isNil';
-import isObject from 'lodash/isObject';
-
 /** Determines whether the given `formData` represents valid form data, such as a primitive type, an array, or a
  * non-empty object.
  *
@@ -9,5 +5,11 @@ import isObject from 'lodash/isObject';
  * @returns - True if `formData` is not undefined, null, a primitive type or an array or an empty object
  */
 export default function isFormDataAvailable<T = any>(formData?: T): boolean {
-  return !isNil(formData) && (!isObject(formData) || Array.isArray(formData) || !isEmpty(formData));
+  if (formData === undefined || formData === null) {
+    return false;
+  }
+  if (typeof formData !== 'object' || Array.isArray(formData)) {
+    return true;
+  }
+  return Object.keys(formData).length > 0;
 }

package/src/isObject.ts

@@ -1,21 +1,33 @@
+import type { GenericObjectType } from './types.ts';
+
 /** Determines whether a `thing` is an object for the purposes of RJSF. In this case, `thing` is an object if it has
  * the type `object` but is NOT null, an array or a File.
  *
  * @param thing - The thing to check to see whether it is an object
  * @returns - True if it is a non-null, non-array, non-File object
  */
-export default function isObject(thing: any): thing is object {
+export default function isObject(thing: unknown): thing is GenericObjectType {
   if (typeof thing !== 'object' || thing === null) {
     return false;
   }
   // lastModified is guaranteed to be a number on a File instance
   // as per https://w3c.github.io/FileAPI/#dfn-lastModified
-  if (typeof thing.lastModified === 'number' && typeof File !== 'undefined' && thing instanceof File) {
+  if (
+    'lastModified' in thing &&
+    typeof thing.lastModified === 'number' &&
+    typeof File !== 'undefined' &&
+    thing instanceof File
+  ) {
     return false;
   }
   // getMonth is guaranteed to be a method on a Date instance
   // as per https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date.prototype.getmonth
-  if (typeof thing.getMonth === 'function' && typeof Date !== 'undefined' && thing instanceof Date) {
+  if (
+    'getMonth' in thing &&
+    typeof thing.getMonth === 'function' &&
+    typeof Date !== 'undefined' &&
+    thing instanceof Date
+  ) {
     return false;
   }
   return !Array.isArray(thing);

package/src/isPlainObject.ts

@@ -0,0 +1,14 @@
+/** Determines whether `thing` is a plain object, i.e. one created by the `Object` constructor or with a `null`
+ * prototype. Unlike `isObject()`, class instances such as `Error` are not plain objects, which matters when
+ * recursively walking a structure whose nested values are expected to be plain data.
+ *
+ * @param thing - The thing to check to see whether it is a plain object
+ * @returns - True if it is a plain object, otherwise false
+ */
+export default function isPlainObject(thing: unknown): thing is Record<string, unknown> {
+  if (typeof thing !== 'object' || thing === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(thing);
+  return proto === null || proto === Object.prototype;
+}

package/src/isRootSchema.ts

@@ -1,6 +1,6 @@
-import { REF_KEY } from './constants';
-import deepEquals from './deepEquals';
-import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types';
+import { REF_KEY } from './constants.ts';
+import deepEquals from './deepEquals.ts';
+import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** 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

package/src/logUnsupportedDefaultForEnum.ts

@@ -1,5 +1,5 @@
-import enumOptionsIndexForValue from './enumOptionsIndexForValue';
-import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types';
+import enumOptionsIndexForValue from './enumOptionsIndexForValue.ts';
+import type { EnumOptionsType, RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Logs a warning when a single-select enum widget has a schema default that is not one of its enum options.
  *

package/src/lookupFromFormContext.ts

@@ -1,8 +1,6 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-
-import { FORM_CONTEXT_NAME, LOOKUP_MAP_NAME } from './constants';
-import type { FormContextType, RJSFSchema, Registry, StrictRJSFSchema } from './types';
+import { FORM_CONTEXT_NAME, LOOKUP_MAP_NAME } from './constants.ts';
+import { getByPath, hasByPath } from './pathUtils.ts';
+import type { FormContextType, RJSFSchema, Registry, StrictRJSFSchema } from './types.ts';
 
 /** 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`
@@ -17,10 +15,11 @@ export default function lookupFromFormContext<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
->(regOrFc: Registry<T, S, F> | Registry<T, S, F>['formContext'], toLookup: string, fallback?: unknown) {
+  R = unknown,
+>(regOrFc: Registry<T, S, F> | Registry<T, S, F>['formContext'], toLookup: string, fallback?: R): R {
   const lookupPath = [LOOKUP_MAP_NAME];
-  if (has(regOrFc, FORM_CONTEXT_NAME)) {
+  if (hasByPath(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return get(regOrFc, [...lookupPath, toLookup], fallback);
+  return getByPath<R>(regOrFc, [...lookupPath, toLookup], fallback);
 }

package/src/mergeDefaultsWithFormData.ts

@@ -1,8 +1,5 @@
-import get from 'lodash/get';
-import isNil from 'lodash/isNil';
-
-import type { GenericObjectType } from '../src';
-import isObject from './isObject';
+import type { GenericObjectType } from './index.ts';
+import isObject from './isObject.ts';
 
 /** Merges the `defaults` object of type `T` into the `formData` of type `T`
  *
@@ -64,27 +61,34 @@ export default function mergeDefaultsWithFormData<T = any>(
   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((accumulator, key) => {
-      const keyValue = get(formData, key);
-      const keyExistsInDefaults = isObject(defaults) && key in (defaults as GenericObjectType);
-      const keyExistsInFormData = key in (formData as GenericObjectType);
-      const keyDefault = get(defaults, key) ?? {};
-      const defaultValueIsNestedObject =
-        keyExistsInDefaults && isObject(keyDefault) && Object.values(keyDefault).some((v) => isObject(v));
+    const formDataObj: GenericObjectType = formData;
+    const defaultsObj: GenericObjectType | undefined = isObject(defaults) ? defaults : undefined;
+    return Object.keys(formDataObj).reduce((accumulator, key) => {
+      const keyValue = formDataObj[key];
+      const keyExistsInDefaults = defaultsObj !== undefined && key in defaultsObj;
+      const keyExistsInFormData = key in formDataObj;
+      const keyDefault = defaultsObj?.[key] ?? {};
+      // If any direct child of this key's default is itself an object or array,
+      // the shallow spread below would bypass its merge rules. Route those cases
+      // to the recursive path; the recursive call repeats this check one level deeper.
+      const defaultValueNeedsDeepMerge =
+        keyExistsInDefaults &&
+        isObject(keyDefault) &&
+        Object.values(keyDefault).some((v) => isObject(v) || Array.isArray(v));
 
-      const keyDefaultIsObject = keyExistsInDefaults && isObject(get(defaults, key));
+      const keyDefaultIsObject = keyExistsInDefaults && isObject(defaultsObj?.[key]);
       const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
 
-      if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
+      if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueNeedsDeepMerge) {
         accumulator[key as keyof T] = {
-          ...get(defaults, key),
+          ...defaultsObj?.[key],
           ...keyValue,
         };
         return accumulator;
       }
 
       accumulator[key as keyof T] = mergeDefaultsWithFormData<T>(
-        get(defaults, key),
+        defaultsObj?.[key],
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -104,8 +108,8 @@ export default function mergeDefaultsWithFormData<T = any>(
    */
   if (
     (defaultSupercedesUndefined &&
-      ((!(defaults === undefined) && isNil(formData)) || (typeof formData === 'number' && Number.isNaN(formData)))) ||
-    (overrideFormDataWithDefaults && !isNil(formData))
+      ((!(defaults === undefined) && formData == null) || (typeof formData === 'number' && Number.isNaN(formData)))) ||
+    (overrideFormDataWithDefaults && formData != null)
   ) {
     return defaults;
   }

package/src/mergeObjects.ts

@@ -1,5 +1,5 @@
-import isObject from './isObject';
-import type { GenericObjectType } from './types';
+import isObject from './isObject.ts';
+import type { GenericObjectType } from './types.ts';
 
 /** Recursively merge deeply nested objects.
  *

package/src/mergeSchemas.ts

@@ -1,9 +1,7 @@
-import union from 'lodash/union';
-
-import { REQUIRED_KEY } from './constants';
-import getSchemaType from './getSchemaType';
-import isObject from './isObject';
-import type { GenericObjectType, GenericSymbolObjectType } from './types';
+import { REQUIRED_KEY } from './constants.ts';
+import getSchemaType from './getSchemaType.ts';
+import isObject from './isObject.ts';
+import type { GenericObjectType, GenericSymbolObjectType } from './types.ts';
 
 /** 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
@@ -29,7 +27,7 @@ export default function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjec
       Array.isArray(right)
     ) {
       // Don't include duplicate values when merging 'required' fields.
-      accumulator[key] = union(left, right);
+      accumulator[key] = [...new Set([...left, ...right])];
     } else {
       accumulator[key] = right;
     }

package/src/nameGenerators.ts

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

package/src/noop.ts

@@ -0,0 +1,4 @@
+/** A function that does nothing and returns `undefined`, useful as a placeholder for an optional callback or as the
+ * implementation of a mocked function.
+ */
+export default function noop(): void {}

package/src/optionsList.ts

@@ -1,10 +1,10 @@
-import get from 'lodash/get';
-
-import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY } from './constants';
-import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema';
-import getUiOptions from './getUiOptions';
-import toConstant from './toConstant';
-import type { RJSFSchema, EnumOptionsType, EnumValue, StrictRJSFSchema, FormContextType, UiSchema } from './types';
+import { CONST_KEY, DEFAULT_KEY } from './constants.ts';
+import getDiscriminatorFieldFromSchema from './getDiscriminatorFieldFromSchema.ts';
+import getPropertySchema from './getPropertySchema.ts';
+import getUiOptions from './getUiOptions.ts';
+import { getByPath } from './pathUtils.ts';
+import toConstant from './toConstant.ts';
+import type { RJSFSchema, EnumOptionsType, EnumValue, StrictRJSFSchema, FormContextType, UiSchema } from './types.ts';
 
 /** 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
@@ -85,8 +85,8 @@ export default function optionsList<T = any, S extends StrictRJSFSchema = RJSFSc
     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));
+      const innerSchema = getPropertySchema<S>(aSchema, selectorField);
+      value = getByPath(innerSchema, DEFAULT_KEY, getByPath(innerSchema, CONST_KEY));
       // Use nullish coalescing so that an explicitly empty string title is preserved
       label = label ?? innerSchema?.title ?? aSchema.title ?? String(value);
     } else {

package/src/orderProperties.ts

@@ -1,4 +1,4 @@
-import type { GenericObjectType } from './types';
+import type { GenericObjectType } from './types.ts';
 
 /** 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

package/src/parseDateString.ts

@@ -1,4 +1,4 @@
-import type { DateObject } from './types';
+import type { DateObject } from './types.ts';
 
 /** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true
  *

package/src/parser/ParserValidator.ts

@@ -1,8 +1,6 @@
-import get from 'lodash/get';
-
-import { ID_KEY } from '../constants';
-import deepEquals from '../deepEquals';
-import hashForSchema from '../hashForSchema';
+import { ID_KEY } from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import hashForSchema from '../hashForSchema.ts';
 import type {
   CustomValidator,
   ErrorSchema,
@@ -14,7 +12,7 @@ import type {
   UiSchema,
   ValidationData,
   ValidatorType,
-} from '../types';
+} from '../types.ts';
 
 /** The type of the map of schema hash to schema
  */
@@ -62,7 +60,7 @@ export default class ParserValidator<
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema: S, hash: string) {
-    const key = get(schema, ID_KEY, hash);
+    const key = schema[ID_KEY] ?? hash;
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {

package/src/parser/index.ts

@@ -1,5 +1,5 @@
-import type { SchemaMap } from './ParserValidator';
-import schemaParser from './schemaParser';
+import type { SchemaMap } from './ParserValidator.ts';
+import schemaParser from './schemaParser.ts';
 
 export type { SchemaMap };
 

package/src/parser/schemaParser.ts

@@ -1,11 +1,9 @@
-import forEach from 'lodash/forEach';
-
-import { ITEMS_KEY, PROPERTIES_KEY } from '../constants';
-import deepEquals from '../deepEquals';
-import { resolveAnyOrOneOfSchemas, retrieveSchemaInternal } from '../schema/retrieveSchema';
-import type { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types';
-import type { SchemaMap } from './ParserValidator';
-import ParserValidator from './ParserValidator';
+import { ITEMS_KEY, PROPERTIES_KEY } from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import { resolveAnyOrOneOfSchemas, retrieveSchemaInternal } from '../schema/retrieveSchema.ts';
+import type { FormContextType, RJSFSchema, StrictRJSFSchema } from '../types.ts';
+import type { SchemaMap } from './ParserValidator.ts';
+import ParserValidator from './ParserValidator.ts';
 
 /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
  * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
@@ -31,9 +29,9 @@ function parseSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends
       const allOptions = resolveAnyOrOneOfSchemas<T, S, F>(validator, localSchema, rootSchema, true);
       allOptions.forEach((s) => {
         if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-          forEach(localSchema[PROPERTIES_KEY], (value) => {
+          for (const value of Object.values(localSchema[PROPERTIES_KEY] ?? {})) {
             parseSchema<T, S, F>(validator, recurseList, rootSchema, value as S);
-          });
+          }
         }
       });
       if (ITEMS_KEY in localSchema && !Array.isArray(localSchema.items) && typeof localSchema.items !== 'boolean') {