@rjsf/utils 6.8.0 → 6.10.0

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') {

package/src/pathUtils.ts

@@ -0,0 +1,203 @@
+import type { FieldPathList } from './types.ts';
+
+/** A path into an object: either a list of path segments or a single property key (string or number).
+ * A bare string is ALWAYS treated as one literal key — `'a.b'` is the key `'a.b'`, not a deep path. To
+ * traverse a dotted path string, convert it explicitly with {@link toPath}
+ */
+export type ObjectPath = string | number | FieldPathList;
+
+/** Matches unsigned integer strings that represent valid array indexes */
+const reIsIndex = /^(?:0|[1-9]\d*)$/;
+
+/** Converts a dotted path string, such as produced for validation error properties, into its list of
+ * path segments. Array indexes may be written bracketed (`'a[0].b'`) or dotted (`'a.0.b'`), and empty
+ * segments — from a leading `.`, a trailing `.` or a `..` run — are dropped.
+ *
+ * Only the grammar RJSF itself produces is supported: dots and brackets are always separators, so
+ * quoted keys are not recognized and keys containing dots must be addressed with a segment list
+ * instead of a string.
+ *
+ * @param path - The string path to convert, such as `'.level1.level2[2].level3'`
+ * @returns - The list of path segments, such as `['level1', 'level2', '2', 'level3']`
+ */
+export function toPath(path: string): string[] {
+  return path.split(/[.[\]]+/).filter(Boolean);
+}
+
+/** Normalizes an `ObjectPath` into a list of path segments, wrapping a single key into a one-element list */
+function normalizePath(path: ObjectPath): FieldPathList {
+  return Array.isArray(path) ? path : [path];
+}
+
+/** Determines whether a path segment could mutate the prototype chain. Only `__proto__` can: assigning to it
+ * invokes the prototype setter rather than creating an own property. `constructor` and `prototype` are safe
+ * here — and are legal JSON Schema property names — because both reads and writes below are own-property-only,
+ * so `['constructor', 'prototype', 'polluted']` shadows `constructor` with a fresh object instead of walking
+ * into `Object.prototype`. Only writes need this check; reads are already own-property-only
+ */
+function isUnsafeSegment(segment: string | number): boolean {
+  return segment === '__proto__';
+}
+
+/** Determines whether a path segment represents a valid array index */
+function isIndex(segment: string | number): boolean {
+  return typeof segment === 'number' ? Number.isInteger(segment) && segment >= 0 : reIsIndex.test(segment);
+}
+
+/** Determines whether `value` can hold properties, i.e. is an object (arrays included) or a function */
+function isSettable(value: unknown): value is Record<PropertyKey, unknown> {
+  return value != null && (typeof value === 'object' || typeof value === 'function');
+}
+
+/** Gets the value at `path` of `obj`, returning `defaultValue` when the resolved value is `undefined`
+ *
+ * Every segment must be an OWN property, matching {@link hasByPath}, so the two can be used as a
+ * guard/read pair. Inherited members are never resolved: `getByPath({}, 'toString')` returns
+ * `defaultValue`, not `Function.prototype.toString`. For the plain form data and schemas RJSF navigates,
+ * an inherited member is never data, and the own-property rule also makes prototype internals such as
+ * `__proto__` unreachable unless they are genuine own data keys
+ *
+ * An empty segment list resolves to nothing, so `defaultValue` is returned. This matches {@link hasByPath},
+ * which is `false` for an empty path, and keeps a computed-but-empty path (`toPath('')` for a root-level
+ * validation error, say) from resolving to the whole object
+ *
+ * The value at a runtime-computed path cannot be known statically, so `R` is the CALLER'S declaration of
+ * the expected type (like `Map.get()`); it defaults to `unknown`, which forces narrowing when no type is given
+ *
+ * @param obj - The object to query
+ * @param path - The single key or list of path segments at which to get the value
+ * @param [defaultValue] - The value returned when the resolved value is `undefined`
+ * @returns - The resolved value, otherwise `defaultValue`
+ */
+export function getByPath<R = unknown>(obj: unknown, path: ObjectPath, defaultValue?: R): R {
+  let current: unknown;
+  if (!Array.isArray(path)) {
+    // Fast path for the most common call shape, a single constant key, avoiding the segment-list allocation
+    current = isSettable(obj) && Object.hasOwn(obj, path) ? obj[path] : undefined;
+  } else if (path.length === 0) {
+    // An empty path resolves to nothing, mirroring `hasByPath()`
+    current = undefined;
+  } else {
+    current = obj;
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i];
+      // Only own data keys resolve, so inherited members and prototype internals are never read
+      if (!isSettable(current) || !Object.hasOwn(current, segment)) {
+        current = undefined;
+        break;
+      }
+      current = current[segment];
+    }
+  }
+  // The single deliberate cast in these utilities: the resolved value is trusted to be the `R` the caller declared
+  return (current === undefined ? defaultValue : current) as R;
+}
+
+/** Sets `value` at `path` of `obj`, mutating and returning `obj`. Missing intermediate containers are
+ * created: arrays when the next segment is a valid array index, plain objects otherwise (or always plain
+ * objects when `createIntermediateObjects` is true)
+ *
+ * A `__proto__` segment is refused in any position — assigning to it would mutate the prototype chain rather
+ * than create an own property — and the write is silently skipped. Every other key, `constructor` and
+ * `prototype` included, is written as an own property
+ *
+ * @param obj - The object to modify
+ * @param path - The single key or list of path segments at which to set the value
+ * @param value - The value to set
+ * @param [createIntermediateObjects] - When true, always create plain objects for missing intermediate
+ *        containers, even for numeric path segments
+ * @returns - The mutated `obj`
+ */
+export function setByPath<O>(obj: O, path: ObjectPath, value: unknown, createIntermediateObjects = false): O {
+  if (!isSettable(obj)) {
+    return obj;
+  }
+  // Fast path for a single constant key, avoiding the segment-list allocation
+  if (!Array.isArray(path)) {
+    // Refuse a segment that could mutate the prototype chain (prototype pollution)
+    if (!isUnsafeSegment(path)) {
+      const target: Record<PropertyKey, unknown> = obj;
+      target[path] = value;
+    }
+    return obj;
+  }
+  const segments = path;
+  // Refuse paths that could mutate the prototype chain (prototype pollution)
+  if (segments.some(isUnsafeSegment)) {
+    return obj;
+  }
+  let current: Record<PropertyKey, unknown> = obj;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (i === segments.length - 1) {
+      current[segment] = value;
+    } else {
+      // Own properties only, so an inherited member is never traversed into
+      const existing = Object.hasOwn(current, segment) ? current[segment] : undefined;
+      if (isSettable(existing)) {
+        current = existing;
+      } else {
+        const next = createIntermediateObjects || !isIndex(segments[i + 1]) ? {} : [];
+        current[segment] = next;
+        /* v8 ignore next -- a fresh {} or [] is always settable; the guard exists only to narrow the type */
+        if (isSettable(next)) {
+          current = next;
+        }
+      }
+    }
+  }
+  return obj;
+}
+
+/** Determines whether `obj` has an own property at `path`
+ *
+ * Every segment is checked with `Object.hasOwn()`, so inherited properties report `false` —
+ * `hasByPath({}, 'toString')` is `false`. {@link getByPath} applies the same own-property rule, so the
+ * two can be used as a guard/read pair
+ *
+ * @param obj - The object to query
+ * @param path - The single key or list of path segments to check for
+ * @returns - True if the own property exists at `path`, otherwise false
+ */
+export function hasByPath(obj: unknown, path: ObjectPath): boolean {
+  // Fast path for a single constant key, avoiding the segment-list allocation
+  if (!Array.isArray(path)) {
+    return isSettable(obj) && Object.hasOwn(obj, path);
+  }
+  let current: unknown = obj;
+  for (let i = 0; i < path.length; i++) {
+    if (!isSettable(current) || !Object.hasOwn(current, path[i])) {
+      return false;
+    }
+    current = current[path[i]];
+  }
+  return path.length > 0;
+}
+
+/** Removes the own property at `path` of `obj`, mutating `obj`
+ *
+ * Both the parent lookup and the delete are own-property-only, so no segment can reach the prototype chain and
+ * no `UNSAFE_SEGMENTS`-style guard is needed: deleting a `__proto__` that is not an own property is a no-op
+ *
+ * @param obj - The object to modify
+ * @param path - The single key or list of path segments at which to remove the property
+ * @returns - True if the property was removed or did not exist, otherwise false
+ */
+export function unsetByPath(obj: unknown, path: ObjectPath): boolean {
+  const segments = normalizePath(path);
+  // An empty path names no property, so there is nothing to remove
+  if (segments.length === 0) {
+    return true;
+  }
+  const parent = segments.length > 1 ? getByPath(obj, segments.slice(0, -1)) : obj;
+  if (parent == null) {
+    return true;
+  }
+  try {
+    // Returns false for a non-configurable property instead of throwing like `delete` in strict mode
+    return Reflect.deleteProperty(parent, segments[segments.length - 1]);
+  } catch {
+    // Reflect.deleteProperty throws when the target is a primitive
+    return false;
+  }
+}

package/src/rangeSpec.ts

@@ -1,4 +1,4 @@
-import type { RangeSpecType, RJSFSchema, StrictRJSFSchema } from './types';
+import type { RangeSpecType, RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
  * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.

package/src/removeOptionalEmptyObjects.ts

@@ -1,6 +1,6 @@
-import isObject from './isObject';
-import { isValueEmpty, retrieveSchema } from './schema';
-import type { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from './types';
+import isObject from './isObject.ts';
+import { isValueEmpty, retrieveSchema } from './schema/index.ts';
+import type { FormContextType, GenericObjectType, RJSFSchema, StrictRJSFSchema, ValidatorType } from './types.ts';
 
 /** 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

package/src/resolveUiSchema.ts

@@ -1,8 +1,6 @@
-import isEmpty from 'lodash/isEmpty';
-
-import { ANY_OF_KEY, ONE_OF_KEY, REF_KEY, RJSF_REF_KEY } from './constants';
-import findSchemaDefinition from './findSchemaDefinition';
-import mergeObjects from './mergeObjects';
+import { ANY_OF_KEY, ONE_OF_KEY, REF_KEY, RJSF_REF_KEY } from './constants.ts';
+import findSchemaDefinition from './findSchemaDefinition.ts';
+import mergeObjects from './mergeObjects.ts';
 import type {
   FormContextType,
   GenericObjectType,
@@ -11,7 +9,7 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   UiSchema,
-} from './types';
+} from './types.ts';
 
 /** Resolves the uiSchema for a given schema, considering `ui:definitions` stored in the registry.
  *
@@ -41,7 +39,7 @@ export default function resolveUiSchema<
   let result: UiSchema<T, S, F>;
   if (!definitionUiSchema) {
     result = localUiSchema || {};
-  } else if (!localUiSchema || isEmpty(localUiSchema)) {
+  } else if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
     result = { ...definitionUiSchema };
   } else {
     result = mergeObjects(definitionUiSchema as GenericObjectType, localUiSchema as GenericObjectType) as UiSchema<