@rjsf/utils 6.7.1 → 6.10.0

package/src/schema/sanitizeDataForNewSchema.ts

@@ -1,8 +1,7 @@
-import get from 'lodash/get';
-import has from 'lodash/has';
-
-import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY, REF_KEY } from '../constants';
-import deepEquals from '../deepEquals';
+import { CONST_KEY, DEFAULT_KEY, PROPERTIES_KEY, REF_KEY } from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import getPropertySchema from '../getPropertySchema.ts';
+import { getByPath, hasByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -10,8 +9,8 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
 const NO_VALUE = Symbol('no Value');
 
@@ -43,7 +42,7 @@ function replacementForInvalidEnumValue<S extends StrictRJSFSchema = RJSFSchema>
     return NO_VALUE;
   }
 
-  const defaultValue = get(schema, DEFAULT_KEY, NO_VALUE);
+  const defaultValue = getByPath(schema, DEFAULT_KEY, NO_VALUE);
   if (defaultValue !== NO_VALUE && enumValues.some((value) => deepEquals(value, defaultValue))) {
     return defaultValue;
   }
@@ -70,7 +69,7 @@ function replacementForInvalidEnumValue<S extends StrictRJSFSchema = RJSFSchema>
  *       - Otherwise, check for default or const values:
  *         - Get the old and new `default` values from the schema and check:
  *           - If the new `default` value does not match the form value:
- *             - If the old `default` value DOES match the form value, then:
+ *             - If the key is new and its form value is undefined, or the old `default` matches the form value, then:
  *               - Replace `removeOldSchemaData[key]` with the new `default`
  *               - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined
  *         - Get the old and new `const` values from the schema and check:
@@ -79,7 +78,7 @@ function replacementForInvalidEnumValue<S extends StrictRJSFSchema = RJSFSchema>
  *             - Replace `removeOldSchemaData[key]` with the new `const`
  *             - Otherwise, replace `removeOldSchemaData[key]` with undefined
  *   - Once all keys have been processed, return an object built as follows:
- *     - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }`
+ *     - `{ ...data, ...removeOldSchemaData, ...nestedData }`
  * - If the new and old schema types are array and the `data` is an array then:
  *   - If the type of the old and new schema `items` are a non-array objects:
  *     - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items`
@@ -113,27 +112,29 @@ export default function sanitizeDataForNewSchema<
 ): T {
   // By default, we will clear the form data
   let newFormData;
+  const newProperties = newSchema?.[PROPERTIES_KEY];
   // If the new schema is of type object and that object contains a list of properties
-  if (has(newSchema, PROPERTIES_KEY)) {
+  if (newProperties) {
     // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data
     const removeOldSchemaData: GenericObjectType = {};
-    if (has(oldSchema, PROPERTIES_KEY)) {
-      const properties = get(oldSchema, PROPERTIES_KEY, {});
-      Object.keys(properties).forEach((key) => {
-        if (has(data, key)) {
+    const oldProperties = oldSchema?.[PROPERTIES_KEY];
+    if (oldProperties) {
+      Object.keys(oldProperties).forEach((key) => {
+        if (hasByPath(data, key)) {
           removeOldSchemaData[key] = undefined;
         }
       });
     }
-    const keys: string[] = Object.keys(get(newSchema, PROPERTIES_KEY, {}));
+    const keys: string[] = Object.keys(newProperties);
     // Create a place to store nested data that will be a side-effect of the filter
     const nestedData: GenericObjectType = {};
     keys.forEach((key) => {
-      const formValue = get(data, key);
-      let oldKeyedSchema: S = get(oldSchema, [PROPERTIES_KEY, key], {}) as S;
-      let newKeyedSchema: S = get(newSchema, [PROPERTIES_KEY, key], {}) as S;
+      const formValue = data?.[key];
+      const isNewProperty = !hasByPath(oldSchema, [PROPERTIES_KEY, key]);
+      let oldKeyedSchema = getPropertySchema<S>(oldSchema, key);
+      let newKeyedSchema = getPropertySchema<S>(newSchema, key);
       // Resolve the refs if they exist
-      if (has(oldKeyedSchema, REF_KEY)) {
+      if (hasByPath(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema<T, S, F>(
           validator,
           oldKeyedSchema,
@@ -142,7 +143,7 @@ export default function sanitizeDataForNewSchema<
           experimental_customMergeAllOf,
         );
       }
-      if (has(newKeyedSchema, REF_KEY)) {
+      if (hasByPath(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema<T, S, F>(
           validator,
           newKeyedSchema,
@@ -152,11 +153,11 @@ export default function sanitizeDataForNewSchema<
         );
       }
       // Now get types and see if they are the same
-      const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
-      const newSchemaTypeForKey = get(newKeyedSchema, 'type');
+      const oldSchemaTypeForKey = oldKeyedSchema.type;
+      const newSchemaTypeForKey = newKeyedSchema.type;
       // Check if the old option has the same key with the same type
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-        if (has(removeOldSchemaData, key)) {
+        if (key in removeOldSchemaData) {
           // SIDE-EFFECT: remove the undefined value for a key that has the same type between the old and new schemas
           delete removeOldSchemaData[key];
         }
@@ -167,7 +168,7 @@ export default function sanitizeDataForNewSchema<
             validator,
             rootSchema,
             newKeyedSchema,
-            oldKeyedSchema,
+            isNewProperty && newSchemaTypeForKey === 'array' ? newKeyedSchema : oldKeyedSchema,
             formValue,
             experimental_customMergeAllOf,
           );
@@ -179,26 +180,26 @@ 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_KEY, NO_VALUE);
-          const oldOptionDefault = get(oldKeyedSchema, DEFAULT_KEY, NO_VALUE);
+          const newOptionDefault = getByPath(newKeyedSchema, DEFAULT_KEY, NO_VALUE);
+          const oldOptionDefault = getByPath(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
+            if ((isNewProperty && formValue === undefined) || oldOptionDefault === formValue) {
+              // Initialize a newly entered property or replace an old default with the new default.
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get(newKeyedSchema, 'readOnly') === true) {
+            } else if (newKeyedSchema.readOnly === true) {
               // If the new schema has the default set to read-only, treat it like a const and remove the value
               removeOldSchemaData[key] = undefined;
             }
           }
 
-          const newOptionConst = get(newKeyedSchema, CONST_KEY, NO_VALUE);
-          const oldOptionConst = get(oldKeyedSchema, CONST_KEY, NO_VALUE);
+          const newOptionConst = getByPath(newKeyedSchema, CONST_KEY, NO_VALUE);
+          const oldOptionConst = getByPath(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)) {
+          if (hasByPath(data, key)) {
             const enumReplacement = replacementForInvalidEnumValue(newKeyedSchema, formValue);
             if (enumReplacement !== NO_VALUE) {
               removeOldSchemaData[key] = enumReplacement;
@@ -214,9 +215,9 @@ export default function sanitizeDataForNewSchema<
       ...nestedData,
     };
     // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep
-  } else if (get(oldSchema, 'type') === 'array' && get(newSchema, 'type') === 'array' && Array.isArray(data)) {
-    let oldSchemaItems = get(oldSchema, 'items');
-    let newSchemaItems = get(newSchema, 'items');
+  } else if (oldSchema?.type === 'array' && newSchema?.type === 'array' && Array.isArray(data)) {
+    let oldSchemaItems = oldSchema.items;
+    let newSchemaItems = newSchema.items;
     // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data
     // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations
     if (
@@ -225,7 +226,7 @@ export default function sanitizeDataForNewSchema<
       !Array.isArray(oldSchemaItems) &&
       !Array.isArray(newSchemaItems)
     ) {
-      if (has(oldSchemaItems, REF_KEY)) {
+      if (hasByPath(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema<T, S, F>(
           validator,
           oldSchemaItems as S,
@@ -234,7 +235,7 @@ export default function sanitizeDataForNewSchema<
           experimental_customMergeAllOf,
         );
       }
-      if (has(newSchemaItems, REF_KEY)) {
+      if (hasByPath(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema<T, S, F>(
           validator,
           newSchemaItems as S,
@@ -244,11 +245,11 @@ export default function sanitizeDataForNewSchema<
         );
       }
       // Now get types and see if they are the same
-      const oldSchemaType = get(oldSchemaItems, 'type');
-      const newSchemaType = get(newSchemaItems, 'type');
+      const oldSchemaType = getByPath(oldSchemaItems, 'type');
+      const newSchemaType = getByPath(newSchemaItems, 'type');
       // Check if the old option has the same key with the same type
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get(newSchema, 'maxItems', -1);
+        const maxItems = newSchema.maxItems ?? -1;
         if (newSchemaType === 'object') {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema<T, S, F>(

package/src/schema/toPathSchema.ts

@@ -1,7 +1,4 @@
 // oxlint-disable typescript/no-deprecated
-import get from 'lodash/get';
-import isObject from 'lodash/isObject';
-import set from 'lodash/set';
 
 import {
   ADDITIONAL_PROPERTIES_KEY,
@@ -15,9 +12,12 @@ import {
   PROPERTIES_KEY,
   REF_KEY,
   RJSF_ADDITIONAL_PROPERTIES_FLAG,
-} from '../constants';
-import deepEquals from '../deepEquals';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
+} from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import getPropertySchema from '../getPropertySchema.ts';
+import isObject from '../isObject.ts';
+import { getByPath, setByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -26,9 +26,9 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import getClosestMatchingOption from './getClosestMatchingOption';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import getClosestMatchingOption from './getClosestMatchingOption.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
 /** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
  * infinite recursion
@@ -99,11 +99,11 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   }
 
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+    setByPath(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
     const additionalSchema = (
       isObject(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {}
     ) as S;
-    const definedProperties = get(schema, PROPERTIES_KEY, {});
+    const definedProperties = schema[PROPERTIES_KEY] ?? {};
     for (const key of Object.keys((formData ?? {}) as GenericObjectType)) {
       if (!(key in definedProperties)) {
         (pathSchema as PathSchema<GenericObjectType>)[key] = toPathSchemaInternal<T, S, F>(
@@ -111,7 +111,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
           additionalSchema,
           `${name}.${key}`,
           rootSchema,
-          get(formData, [key]),
+          getByPath<T>(formData, key),
           _recurseList,
           experimental_customMergeAllOf,
         );
@@ -166,7 +166,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
     // 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;
+      const field = getPropertySchema<S>(schema, property);
       (pathSchema as PathSchema<GenericObjectType>)[property] = toPathSchemaInternal<T, S, F>(
         validator,
         field,
@@ -174,7 +174,7 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        get(formData, [property]),
+        getByPath<T>(formData, property),
         _recurseList,
         experimental_customMergeAllOf,
       );

package/src/schemaRequiresTrueValue.ts

@@ -1,4 +1,4 @@
-import type { RJSFSchema, StrictRJSFSchema } from './types';
+import type { RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Check to see if a `schema` specifies that a value must be true. This happens when:
  * - `schema.const` is truthy

package/src/shouldRender.ts

@@ -1,7 +1,7 @@
-import React from 'react';
+import type React from 'react';
 
-import deepEquals from './deepEquals';
-import shallowEquals from './shallowEquals';
+import deepEquals from './deepEquals.ts';
+import shallowEquals from './shallowEquals.ts';
 
 /** The supported component update strategies */
 export type ComponentUpdateStrategy = 'customDeep' | 'shallow' | 'always';

package/src/shouldRenderOptionalField.ts

@@ -1,11 +1,9 @@
-import isObject from 'lodash/isObject';
-import uniq from 'lodash/uniq';
-
-import { ANY_OF_KEY, ONE_OF_KEY } from './constants';
-import getSchemaType from './getSchemaType';
-import getUiOptions from './getUiOptions';
-import isRootSchema from './isRootSchema';
-import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types';
+import { ANY_OF_KEY, ONE_OF_KEY } from './constants.ts';
+import getSchemaType from './getSchemaType.ts';
+import getUiOptions from './getUiOptions.ts';
+import isObject from './isObject.ts';
+import isRootSchema from './isRootSchema.ts';
+import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema } from './types.ts';
 
 /** Returns the unique list of schema types for all of the options in a anyOf/oneOf
  *
@@ -13,12 +11,14 @@ import type { FormContextType, Registry, RJSFSchema, StrictRJSFSchema, UiSchema
  * @returns - All of the unique types contained within the oneOf list
  */
 export function getSchemaTypesForXxxOf<S extends StrictRJSFSchema = RJSFSchema>(schemas: S[]): string | string[] {
-  const allTypes: string[] = uniq(
-    schemas
-      .map((s) => (isObject(s) ? getSchemaType(s) : undefined))
-      .flat()
-      .filter((t) => t !== undefined),
-  );
+  const allTypes: string[] = [
+    ...new Set(
+      schemas
+        .map((s) => (isObject(s) ? getSchemaType(s) : undefined))
+        .flat()
+        .filter((t) => t !== undefined),
+    ),
+  ];
   return allTypes.length === 1 ? allTypes[0] : allTypes;
 }
 

package/src/toConstant.ts

@@ -1,5 +1,5 @@
-import { CONST_KEY, ENUM_KEY } from './constants';
-import type { RJSFSchema, StrictRJSFSchema } from './types';
+import { CONST_KEY, ENUM_KEY } from './constants.ts';
+import type { RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
  * throws an error.

package/src/toDateString.ts

@@ -1,4 +1,4 @@
-import type { DateObject } from './types';
+import type { DateObject } from './types.ts';
 
 /** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
  * removed.

package/src/toErrorList.ts

@@ -1,7 +1,6 @@
-import isPlainObject from 'lodash/isPlainObject';
-
-import { ERRORS_KEY } from './constants';
-import type { ErrorSchema, GenericObjectType, RJSFValidationError } from './types';
+import { ERRORS_KEY } from './constants.ts';
+import isPlainObject from './isPlainObject.ts';
+import type { ErrorSchema, RJSFValidationError } from './types.ts';
 
 /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
  *
@@ -13,28 +12,26 @@ export default function toErrorList<T = any>(
   errorSchema?: ErrorSchema<T>,
   fieldPath: string[] = [],
 ): RJSFValidationError[] {
-  if (!errorSchema) {
-    return [];
-  }
-  let errorList: RJSFValidationError[] = [];
-  if (ERRORS_KEY in errorSchema) {
-    errorList = errorList.concat(
-      errorSchema[ERRORS_KEY]!.map((message: string) => {
-        const property = `.${fieldPath.join('.')}`;
-        return {
-          property,
-          message,
-          stack: `${property} ${message}`,
-        };
-      }),
-    );
-  }
+  return errorSchema ? errorsFrom(errorSchema, fieldPath) : [];
+}
+
+/** Does the actual conversion, working on the plain-object shape of an `ErrorSchema` so that the recursive call for a
+ * nested error schema does not need an assertion back to `ErrorSchema`.
+ *
+ * @param errorSchema - The error schema, viewed as the plain object it is at runtime
+ * @param fieldPath - The current field path
+ * @returns - The list of `RJSFValidationErrors` extracted from the `errorSchema`
+ */
+function errorsFrom(errorSchema: Record<string, unknown>, fieldPath: string[]): RJSFValidationError[] {
+  const errors = errorSchema[ERRORS_KEY];
+  const property = `.${fieldPath.join('.')}`;
+  const errorList: RJSFValidationError[] = Array.isArray(errors)
+    ? errors.map((message: string) => ({ property, message, stack: `${property} ${message}` }))
+    : [];
   return Object.keys(errorSchema).reduce((currentList, key) => {
-    if (key !== ERRORS_KEY) {
-      const childSchema = (errorSchema as GenericObjectType)[key];
-      if (isPlainObject(childSchema)) {
-        return currentList.concat(toErrorList(childSchema, [...fieldPath, key]));
-      }
+    const childSchema = errorSchema[key];
+    if (key !== ERRORS_KEY && isPlainObject(childSchema)) {
+      return currentList.concat(errorsFrom(childSchema, [...fieldPath, key]));
     }
     return currentList;
   }, errorList);

package/src/toErrorSchema.ts

@@ -1,7 +1,6 @@
-import toPath from 'lodash/toPath';
-
-import ErrorSchemaBuilder from './ErrorSchemaBuilder';
-import type { ErrorSchema, RJSFValidationError } from './types';
+import ErrorSchemaBuilder from './ErrorSchemaBuilder.ts';
+import { toPath } from './pathUtils.ts';
+import type { ErrorSchema, RJSFValidationError } from './types.ts';
 
 /** Transforms a rjsf validation errors list:
  * [
@@ -27,13 +26,8 @@ export default function toErrorSchema<T = any>(errors: RJSFValidationError[]): E
   if (errors.length) {
     errors.forEach((error) => {
       const { property, message } = error;
-      // When the property is the root element, just use an empty array for the path
-      const path = property === '.' ? [] : toPath(property);
-      // If the property is at the root (.level1) then toPath creates
-      // an empty array element at the first index. Remove it.
-      if (path.length > 0 && path[0] === '') {
-        path.splice(0, 1);
-      }
+      // When the property is missing or the root element ('.'), toPath produces an empty path
+      const path = property ? toPath(property) : [];
       if (message) {
         builder.addErrors(message, path);
       }

package/src/toFieldPathId.ts

@@ -1,5 +1,5 @@
-import { ID_KEY } from './constants';
-import type { FieldPathId, FieldPathList, GlobalFormOptions } from './types';
+import { ID_KEY } from './constants.ts';
+import type { FieldPathId, FieldPathList, GlobalFormOptions } from './types.ts';
 
 /** Constructs the `FieldPathId` for `fieldPath`. If `parentPathId` is provided, the `fieldPath` is appended to the end
  * of the parent path. Then the `ID_KEY` of the resulting `FieldPathId` is constructed from the `idPrefix` and

package/src/types.ts

@@ -10,8 +10,8 @@ import type {
 } from 'react';
 import type { JSONSchema7 } from 'json-schema';
 
-import type { TranslatableString } from './enums';
-import './jsonSchemaAugmentation';
+import type { TranslatableString } from './enums.ts';
+import './jsonSchemaAugmentation.ts';
 
 /** The representation of any generic object type, usually used as an intersection on other types to make them more
  * flexible in the properties they support (i.e. anything else)
@@ -185,6 +185,8 @@ export interface InputPropsType {
   max?: number | string;
   /** Specifies the `autoComplete` value for an <input> element */
   autoComplete?: HTMLInputElement['autocomplete'];
+  /** Specifies the `autoCapitalize` value for an <input> element */
+  autoCapitalize?: HTMLInputElement['autocapitalize'];
   /** Specifies a filter for what file types the user can upload. */
   accept?: HTMLInputElement['accept'];
 }
@@ -1025,7 +1027,12 @@ export interface WidgetProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F
 /** The definition of a React-based Widget component */
 export type Widget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = ComponentType<
   WidgetProps<T, S, F>
->;
+> & {
+  /** A cached wrapper component that merges the widget's `defaultProps.options` into its props, stamped onto the
+   * widget by `getWidget()` so that repeated lookups return the same component for proper React reconciliation
+   */
+  MergedWidget?: Widget<T, S, F>;
+};
 
 /** The properties that are passed to the BaseInputTemplate */
 export interface BaseInputTemplateProps<
@@ -1137,6 +1144,8 @@ type UIOptionsBaseType<T = any, S extends StrictRJSFSchema = RJSFSchema, F exten
     autofocus?: boolean;
     /** Use to mark the field as supporting auto complete on a text input or textarea input */
     autocomplete?: HTMLInputElement['autocomplete'];
+    /** Controls automatic capitalization for text entered on supporting virtual keyboards */
+    autocapitalize?: HTMLInputElement['autocapitalize'];
     /** Flag, if set to `true`, will mark all child widgets from a given field as disabled */
     disabled?: boolean;
     /** The default value to use when an input for a field is empty */
@@ -1435,8 +1444,8 @@ export interface SchemaUtilsType<T = any, S extends StrictRJSFSchema = RJSFSchem
    * @returns - The firstindex of the matched option or 0 if none is available
    */
   getFirstMatchingOption(formData: T | undefined, options: S[], discriminatorField?: string): number;
-  /** Helper that acts like lodash's `get` but additionally retrieves `$ref`s as needed to get the path for schemas
-   * containing potentially nested `$ref`s.
+  /** Reads the value at `path` within a schema, additionally retrieving `$ref`s as needed to resolve
+   * schemas containing potentially nested `$ref`s.
    *
    * @param schema - The current node within the JSON schema recursion
    * @param path - The remaining keys in the path to the desired property

package/src/unwrapErrorHandler.ts

@@ -1,6 +1,5 @@
-import isPlainObject from 'lodash/isPlainObject';
-
-import type { ErrorSchema, FormValidation, GenericObjectType } from './types';
+import isPlainObject from './isPlainObject.ts';
+import type { ErrorSchema, FormValidation } from './types.ts';
 
 /** Unwraps the `errorHandler` structure into the associated `ErrorSchema`, stripping the `addError()` functions from it
  *
@@ -8,15 +7,25 @@ import type { ErrorSchema, FormValidation, GenericObjectType } from './types';
  * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
  */
 export default function unwrapErrorHandler<T = any>(errorHandler: FormValidation<T>): ErrorSchema<T> {
-  return Object.keys(errorHandler).reduce<ErrorSchema<T>>((acc, key) => {
+  return unwrapErrors<T>(errorHandler);
+}
+
+/** Does the actual unwrapping, working on the plain-object shape of a `FormValidation` so that the recursive call for
+ * a nested error handler does not need an assertion back to `FormValidation`.
+ *
+ * @param errors - The error handling structure, viewed as the plain object it is at runtime
+ * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
+ */
+function unwrapErrors<T>(errors: Record<string, unknown>): ErrorSchema<T> {
+  return Object.keys(errors).reduce<ErrorSchema<T>>((acc, key) => {
     if (key === 'addError') {
       return acc;
     }
-    const childSchema = (errorHandler as GenericObjectType)[key];
+    const childSchema = errors[key];
     if (isPlainObject(childSchema)) {
       return {
         ...acc,
-        [key]: unwrapErrorHandler(childSchema),
+        [key]: unwrapErrors<T>(childSchema),
       };
     }
     return { ...acc, [key]: childSchema };

package/src/useAltDateWidgetProps.tsx

@@ -3,13 +3,13 @@
 import type { MouseEvent } from 'react';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import dateRangeOptions from './dateRangeOptions';
-import type { DateElementFormat, DateElementProp } from './getDateElementProps';
-import getDateElementProps from './getDateElementProps';
-import { ariaDescribedByIds } from './idGenerators';
-import parseDateString from './parseDateString';
-import toDateString from './toDateString';
-import type { DateObject, FormContextType, RJSFSchema, StrictRJSFSchema, WidgetProps } from './types';
+import dateRangeOptions from './dateRangeOptions.ts';
+import type { DateElementFormat, DateElementProp } from './getDateElementProps.ts';
+import getDateElementProps from './getDateElementProps.ts';
+import { ariaDescribedByIds } from './idGenerators.ts';
+import parseDateString from './parseDateString.ts';
+import toDateString from './toDateString.ts';
+import type { DateObject, FormContextType, RJSFSchema, StrictRJSFSchema, WidgetProps } from './types.ts';
 
 /** Function that checks to see if a `DateObject` is ready for the onChange callback to be triggered
  *

package/src/useDeepCompareMemo.ts

@@ -2,7 +2,7 @@
 
 import { useRef } from 'react';
 
-import deepEquals from './deepEquals';
+import deepEquals from './deepEquals.ts';
 
 /** Hook that stores and returns a `T` value. If `newValue` is the same as the stored one, then the stored one is
  * returned to avoid having a component rerender due it being a different object. Otherwise, the `newValue` is stored

package/src/useFileWidgetProps.ts

@@ -2,7 +2,7 @@
 
 import { useCallback, useMemo } from 'react';
 
-import dataURItoBlob from './dataURItoBlob';
+import dataURItoBlob from './dataURItoBlob.ts';
 
 /** The information about files used by a FileWidget */
 export interface FileInfoType {

package/src/utcToLocal.ts

@@ -1,4 +1,4 @@
-import pad from './pad';
+import pad from './pad.ts';
 
 /** Converts a UTC date string into a local Date format
  *

package/src/validationDataMerge.ts

@@ -1,8 +1,6 @@
-import isEmpty from 'lodash/isEmpty';
-
-import mergeObjects from './mergeObjects';
-import toErrorList from './toErrorList';
-import type { ErrorSchema, ValidationData } from './types';
+import mergeObjects from './mergeObjects.ts';
+import toErrorList from './toErrorList.ts';
+import type { ErrorSchema, ValidationData } from './types.ts';
 
 /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
  * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
@@ -25,7 +23,7 @@ export default function validationDataMerge<T = any>(
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty(oldErrorSchema)) {
+  if (oldErrorSchema && Object.keys(oldErrorSchema).length > 0) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,

package/src/withIdRefPrefix.ts

@@ -1,7 +1,6 @@
-import isObject from 'lodash/isObject';
-
-import { REF_KEY, ROOT_SCHEMA_PREFIX } from './constants';
-import type { RJSFSchema, StrictRJSFSchema } from './types';
+import { REF_KEY, ROOT_SCHEMA_PREFIX } from './constants.ts';
+import isObject from './isObject.ts';
+import type { RJSFSchema, StrictRJSFSchema } from './types.ts';
 
 /** Takes a `node` object and transforms any contained `$ref` node variables with a prefix, recursively calling
  * `withIdRefPrefix` for any other elements.