@rjsf/utils 6.7.1 → 6.10.0

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<

package/src/schema/findFieldInSchema.ts

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

package/src/schema/findSelectedOptionInXxxOf.ts

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

package/src/schema/getClosestMatchingOption.ts

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