@rjsf/utils 6.7.1 → 6.10.0

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

package/src/schema/index.ts

@@ -1,17 +1,17 @@
-import findFieldInSchema from './findFieldInSchema';
-import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf';
-import getClosestMatchingOption from './getClosestMatchingOption';
-import getDefaultFormState from './getDefaultFormState';
-import getDisplayLabel from './getDisplayLabel';
-import getFirstMatchingOption from './getFirstMatchingOption';
-import getFromSchema from './getFromSchema';
-import isFilesArray from './isFilesArray';
-import isMultiSelect from './isMultiSelect';
-import isSelect from './isSelect';
-import omitExtraData, { getUsedFormData, getFieldNames, isValueEmpty } from './omitExtraData';
-import retrieveSchema, { relaxOptionsForScoring } from './retrieveSchema';
-import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
-import toPathSchema from './toPathSchema';
+import findFieldInSchema from './findFieldInSchema.ts';
+import findSelectedOptionInXxxOf from './findSelectedOptionInXxxOf.ts';
+import getClosestMatchingOption from './getClosestMatchingOption.ts';
+import getDefaultFormState from './getDefaultFormState.ts';
+import getDisplayLabel from './getDisplayLabel.ts';
+import getFirstMatchingOption from './getFirstMatchingOption.ts';
+import getFromSchema from './getFromSchema.ts';
+import isFilesArray from './isFilesArray.ts';
+import isMultiSelect from './isMultiSelect.ts';
+import isSelect from './isSelect.ts';
+import omitExtraData, { getUsedFormData, getFieldNames, isValueEmpty } from './omitExtraData.ts';
+import retrieveSchema, { relaxOptionsForScoring } from './retrieveSchema.ts';
+import sanitizeDataForNewSchema from './sanitizeDataForNewSchema.ts';
+import toPathSchema from './toPathSchema.ts';
 
 export {
   findFieldInSchema,

package/src/schema/isFilesArray.ts

@@ -1,4 +1,4 @@
-import { UI_WIDGET_KEY } from '../constants';
+import { UI_WIDGET_KEY } from '../constants.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -6,8 +6,8 @@ import type {
   StrictRJSFSchema,
   UiSchema,
   ValidatorType,
-} from '../types';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
 /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
  *

package/src/schema/isMultiSelect.ts

@@ -4,8 +4,8 @@ import type {
   StrictRJSFSchema,
   ValidatorType,
   Experimental_CustomMergeAllOf,
-} from '../types';
-import isSelect from './isSelect';
+} from '../types.ts';
+import isSelect from './isSelect.ts';
 
 /** Checks to see if the `schema` combination represents a multi-select
  *

package/src/schema/isSelect.ts

@@ -1,12 +1,12 @@
-import isConstant from '../isConstant';
+import isConstant from '../isConstant.ts';
 import type {
   FormContextType,
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
   Experimental_CustomMergeAllOf,
-} from '../types';
-import retrieveSchema from './retrieveSchema';
+} from '../types.ts';
+import retrieveSchema from './retrieveSchema.ts';
 
 /** Checks to see if the `schema` combination represents a select
  *