@rjsf/utils 6.7.1 → 6.10.0

package/src/schema/omitExtraData.ts

@@ -1,13 +1,9 @@
-import get from 'lodash/get';
-import isEmpty from 'lodash/isEmpty';
-import isNil from 'lodash/isNil';
-import pick from 'lodash/pick';
-
-import { NAME_KEY, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '../constants';
-import findSchemaDefinition from '../findSchemaDefinition';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import getSchemaType from '../getSchemaType';
-import isObject from '../isObject';
+import { NAME_KEY, RJSF_ADDITIONAL_PROPERTIES_FLAG } from '../constants.ts';
+import findSchemaDefinition from '../findSchemaDefinition.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import getSchemaType from '../getSchemaType.ts';
+import isObject from '../isObject.ts';
+import { getByPath, hasByPath, setByPath, toPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -16,11 +12,11 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import getClosestMatchingOption from './getClosestMatchingOption';
-import isSelect from './isSelect';
-import { relaxOptionsForScoring, resolveAllReferences } from './retrieveSchema';
-import shallowAllOfMerge from './shallowAllOfMerge';
+} from '../types.ts';
+import getClosestMatchingOption from './getClosestMatchingOption.ts';
+import isSelect from './isSelect.ts';
+import { relaxOptionsForScoring, resolveAllReferences } from './retrieveSchema.ts';
+import shallowAllOfMerge from './shallowAllOfMerge.ts';
 
 /** Returns the `formData` with only the elements specified in the `fields` list
  *
@@ -34,7 +30,15 @@ export function getUsedFormData<T = any>(formData: T | undefined, fields: string
     return formData;
   }
 
-  const data: GenericObjectType = pick(formData, fields);
+  // Keep only the values at the given field paths; `fields` contains either dotted strings or the
+  // deep path lists produced by `getFieldNames()`
+  const data: GenericObjectType = {};
+  fields.forEach((field) => {
+    const path = Array.isArray(field) ? field : toPath(field);
+    if (hasByPath(formData, path)) {
+      setByPath(data, path, getByPath(formData, path));
+    }
+  });
   if (Array.isArray(formData)) {
     return Object.keys(data).map((key: string) => data[key]) as unknown as T;
   }
@@ -50,8 +54,13 @@ export function getUsedFormData<T = any>(formData: T | undefined, fields: string
  */
 // oxlint-disable-next-line typescript/no-deprecated
 export function getFieldNames<T = any>(pathSchema: PathSchema<T>, formData?: T): string[][] {
-  const formValueHasData = (value: T, isLeaf: boolean) =>
-    typeof value !== 'object' || isEmpty(value) || (isLeaf && !isEmpty(value));
+  const formValueHasData = (value: unknown, isLeaf: boolean) => {
+    if (typeof value !== 'object' || value === null) {
+      return true;
+    }
+    const isEmptyValue = Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0;
+    return isEmptyValue || isLeaf;
+  };
   const getAllPaths = (_obj: GenericObjectType, acc: string[][] = [], paths: string[][] = [[]]) => {
     const objKeys = Object.keys(_obj);
     objKeys.forEach((key: string) => {
@@ -66,12 +75,12 @@ export function getFieldNames<T = any>(pathSchema: PathSchema<T>, formData?: T):
         }
       } else if (key === NAME_KEY && data !== '') {
         paths.forEach((path) => {
-          const formValue = get(formData, path);
+          const formValue = getByPath(formData, path);
           const isLeaf = objKeys.length === 1;
           // adds path to fieldNames if it points to a value or an empty object/array which is not a leaf
           if (
             formValueHasData(formValue, isLeaf) ||
-            (Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf)))
+            (Array.isArray(formValue) && formValue.every((val: unknown) => formValueHasData(val, isLeaf)))
           ) {
             acc.push(path);
           }
@@ -91,14 +100,14 @@ export function getFieldNames<T = any>(pathSchema: PathSchema<T>, formData?: T):
  * @returns - True if the value is considered empty, false otherwise
  */
 export function isValueEmpty(value: unknown): boolean {
-  if (isNil(value) || value === '') {
+  if (value == null || value === '') {
     return true;
   }
   if (Array.isArray(value)) {
     return value.length === 0;
   }
   if (isObject(value)) {
-    return Object.values(value as GenericObjectType).every(isValueEmpty);
+    return Object.values(value).every(isValueEmpty);
   }
   return false;
 }
@@ -163,7 +172,7 @@ export default function omitExtraData<
   }
 
   /** Copies schema-defined properties from `source` into `target`, applying `omit` recursively for
-   * each value. Handles `properties`, `patternProperties`, `additionalProperties`, and `propertyNames`.
+   * each value. Handles `properties`, `patternProperties`, and `additionalProperties`.
    * Optional object-valued properties are pruned when every key in the filtered result is both
    * optional (per the inner schema's `required`) and empty (per `isValueEmpty`). This preserves
    * optional objects whose required children have empty values, while still dropping objects whose
@@ -177,7 +186,7 @@ export default function omitExtraData<
    * @returns - `target` after all schema-defined properties have been processed
    */
   function handleObject(childSchema: S, source: GenericObjectType, target: GenericObjectType): GenericObjectType {
-    const { properties, additionalProperties, patternProperties, propertyNames } = childSchema;
+    const { properties, additionalProperties, patternProperties } = childSchema;
     const requiredSet = new Set(childSchema.required ?? []);
 
     /** Recursively omits extra data from `value` via `omit`, then conditionally writes the result to
@@ -204,9 +213,7 @@ export default function omitExtraData<
         const innerRequired = new Set(sd.required ?? []);
         // Drop this optional object when every key in v is both optional in the inner schema
         // and has an empty value. Vacuously true for {} so empty objects are always dropped.
-        const shouldDrop = Object.entries(v as GenericObjectType).every(
-          ([k, val]) => !innerRequired.has(k) && isValueEmpty(val),
-        );
+        const shouldDrop = Object.entries(v).every(([k, val]) => !innerRequired.has(k) && isValueEmpty(val));
         if (shouldDrop) {
           return;
         }
@@ -262,46 +269,51 @@ export default function omitExtraData<
       }
     }
 
-    // When propertyNames is present, the schema only constrains key names — all source keys are valid.
-    if (propertyNames !== undefined) {
-      for (const [key, value] of Object.entries(source)) {
-        // oxlint-disable-next-line no-param-reassign
-        target[key] = value;
-      }
-    }
-
     return target;
   }
 
   /** Filters array elements from `source` into `target` according to `schema.items` and
-   * `schema.additionalItems`. For tuple schemas (`items` is an array) each element is filtered by its
-   * per-index schema; elements beyond the tuple length are covered by `additionalItems` when present.
-   * For list schemas (`items` is a single schema) every element is filtered by that schema.
+   * `schema.additionalItems`. Only called when `items` is defined (guarded in `omit`). Uses index
+   * assignment (not push) so a pre-populated `target` from a prior branch is overwritten rather than
+   * appended to, preventing item duplication. For tuple schemas (`items` is an array) elements up to
+   * `min(items.length, source.length)` are filtered by their per-index schema; elements beyond the
+   * tuple are covered by `additionalItems` when present, or the target is truncated when absent.
+   * For list schemas (`items` is a single schema) every source element is filtered and `target.length`
+   * is set to `source.length`.
    *
    * @param childSchema - The array schema describing `items` and optionally `additionalItems`
    * @param source - The source array to read elements from
-   * @param target - The accumulator array to push filtered elements into
-   * @returns - `target` after all applicable source elements have been pushed
+   * @param target - The accumulator array to write filtered elements into
+   * @returns - `target` after all applicable source elements have been written
    */
   function handleArray(childSchema: S, source: unknown[], target: unknown[]): unknown[] {
     const { items, additionalItems } = childSchema;
-    if (items !== undefined) {
-      if (Array.isArray(items)) {
-        for (let i = 0; i < items.length; i += 1) {
-          target.push(omit(items[i] as S | boolean, source[i]));
-        }
-      } else {
-        for (let i = 0; i < source.length; i += 1) {
-          target.push(omit(items as S | boolean, source[i]));
-        }
+    if (Array.isArray(items)) {
+      const tupleLength = Math.min(items.length, source.length);
+      let i = 0;
+      for (; i < tupleLength; i += 1) {
+        // oxlint-disable-next-line no-param-reassign
+        target[i] = omit(items[i] as S | boolean, source[i]);
       }
-    }
-    // additionalItems covers tuple items beyond the items array length.
-    if (additionalItems) {
-      for (let i = target.length; i < source.length; i += 1) {
-        target.push(omit(additionalItems as S | boolean, source[i]));
+      // Without additionalItems, truncate at the tuple boundary to drop any pre-existing items.
+      if (!additionalItems) {
+        // oxlint-disable-next-line no-param-reassign
+        target.length = tupleLength;
+        return target;
+      }
+      for (; i < source.length; i += 1) {
+        // oxlint-disable-next-line no-param-reassign
+        target[i] = omit(additionalItems as S | boolean, source[i]);
+      }
+    } else {
+      for (let i = 0; i < source.length; i += 1) {
+        // oxlint-disable-next-line no-param-reassign
+        target[i] = omit(items as S | boolean, source[i]);
       }
     }
+    // Truncate any pre-existing items beyond the source length.
+    // oxlint-disable-next-line no-param-reassign
+    target.length = source.length;
     return target;
   }
 
@@ -326,7 +338,7 @@ export default function omitExtraData<
       ? validator.isValid(condition as S, source as T, rootSchema)
       : condition;
     const branch = isThenBranch ? then : otherwise;
-    return branch === undefined ? target : omit(branch as S | boolean, source, target);
+    return branch === undefined ? target : omit(branch as S | boolean, source, target, false);
   }
 
   /** Applies the best-matching `oneOf` option to `source`, merging the result into `target`. When
@@ -364,7 +376,7 @@ export default function omitExtraData<
     const resolved: S = isObject(winning)
       ? resolveAllReferences<S>(winning, rootSchema, [])
       : scoringOptions[bestIndex];
-    return omit(resolved, source, target);
+    return omit(resolved, source, target, false);
   }
 
   /** Applies `anyOf` branches from `schema` to `source`, merging results into `target`. When `anyOf`
@@ -390,7 +402,7 @@ export default function omitExtraData<
     ) {
       let result = target;
       for (const branch of anyOf as (S | boolean)[]) {
-        result = omit(branch, source, result);
+        result = omit(branch, source, result, false);
       }
       return result;
     }
@@ -416,7 +428,7 @@ export default function omitExtraData<
     for (const [key, deps] of Object.entries(dependencies)) {
       // Skip property dependencies (string arrays); only process schema dependencies.
       if (key in source && !Array.isArray(deps)) {
-        result = omit(deps as S | boolean, source, result);
+        result = omit(deps as S | boolean, source, result, false);
       }
     }
     return result;
@@ -425,26 +437,30 @@ export default function omitExtraData<
   /** Core recursive filter. Resolves `$ref`s, merges `allOf`, then delegates to the type-specific
    * handlers (`handleObject`, `handleArray`) and keyword handlers (`handleAnyOf`, `handleOneOf`,
    * `handleConditions`, `handleDependencies`). Returns `undefined` when `source` is undefined or
-   * `schemaDef` is `false`; returns `source` unchanged when `schemaDef` is `true` or empty.
+   * `schemaDef` is `false`; when `schemaDef` is `true` or empty returns `target ?? source` (when
+   * `useSourceAsFallback` is true) or `target` (when false) to avoid aliasing `source` as the
+   * accumulator across multiple compositional branches.
    *
    * @param schemaDef - The schema (or boolean shorthand) to filter `source` against
    * @param source - The raw form data value to filter
    * @param [target] - An optional accumulator carrying results from prior oneOf/anyOf processing
+   * @param [useSourceAsFallback=true] - When false a permissive schema (`true`/`{}`) returns `target`
+   *   rather than `source`, preventing compositional branches from aliasing the accumulator to `source`
    * @returns - The filtered value, or `undefined` when the schema rejects the value
    */
-  function omit(schemaDef: S | boolean, source: unknown, target?: unknown): unknown {
+  function omit(schemaDef: S | boolean, source: unknown, target?: unknown, useSourceAsFallback = true): unknown {
     if (source === undefined || schemaDef === false) {
       return undefined;
     }
-    if (schemaDef === true || isEmpty(schemaDef as object)) {
-      return source;
+    if (schemaDef === true || !schemaDef || Object.keys(schemaDef).length === 0) {
+      return target ?? (useSourceAsFallback ? source : undefined);
     }
 
     let localSchema = schemaDef;
     const { $ref: ref, allOf } = localSchema;
 
     if (ref !== undefined) {
-      return omit(findSchemaDefinition<S>(ref, rootSchema), source, target);
+      return omit(findSchemaDefinition<S>(ref, rootSchema), source, target, useSourceAsFallback);
     }
     if (allOf) {
       localSchema = doMergeAllOf<S>(localSchema, experimental_customMergeAllOf);
@@ -456,7 +472,7 @@ export default function omitExtraData<
       if (remainingAllOf) {
         for (let i = 0; i < remainingAllOf.length; i++) {
           // oxlint-disable-next-line no-param-reassign
-          target = omit(remainingAllOf[i] as S | boolean, source, target);
+          target = omit(remainingAllOf[i] as S | boolean, source, target, false);
         }
       }
     }
@@ -473,12 +489,32 @@ export default function omitExtraData<
       if (!Array.isArray(source)) {
         return undefined;
       }
-      filtered = handleArray(localSchema, source, Array.isArray(filtered) ? filtered : []);
-    } else if (filtered === undefined) {
-      filtered = source;
+      if (localSchema.items !== undefined) {
+        filtered = handleArray(localSchema, source, Array.isArray(filtered) ? filtered : []);
+      }
     }
 
-    return handleDependencies(localSchema, source, handleConditions(localSchema, source, filtered));
+    // Post-prune after conditions (oneOf/anyOf/if-then) but BEFORE dependencies: keys added by
+    // dependency sub-schemas are legitimate extensions of the allowed property set and must not be
+    // pruned. Keys added only by winning conditional branches are still removed here so the result
+    // honours additionalProperties:false.
+    const afterConditions = handleConditions(localSchema, source, filtered);
+    if (localSchema.additionalProperties === false && isObjectValue(afterConditions)) {
+      const knownKeys = new Set(Object.keys(localSchema.properties ?? {}));
+      const patterns = localSchema.patternProperties
+        ? Object.keys(localSchema.patternProperties).map((p) => new RegExp(p))
+        : [];
+      for (const key of Object.keys(afterConditions)) {
+        if (!knownKeys.has(key) && !patterns.some((re) => re.test(key))) {
+          // oxlint-disable-next-line no-param-reassign
+          delete afterConditions[key];
+        }
+      }
+    }
+
+    const result = handleDependencies(localSchema, source, afterConditions);
+
+    return result ?? (useSourceAsFallback ? source : undefined);
   }
 
   return omit(schema, formData) as T | undefined;

package/src/schema/retrieveSchema.ts

@@ -1,12 +1,3 @@
-import flattenDeep from 'lodash/flattenDeep';
-import get from 'lodash/get';
-import isEmpty from 'lodash/isEmpty';
-import merge from 'lodash/merge';
-import set from 'lodash/set';
-import times from 'lodash/times';
-import transform from 'lodash/transform';
-import uniq from 'lodash/uniq';
-
 import {
   ADDITIONAL_PROPERTIES_KEY,
   ADDITIONAL_PROPERTY_FLAG,
@@ -22,13 +13,14 @@ import {
   REF_KEY,
   RJSF_REF_CYCLE_KEY,
   RJSF_REF_KEY,
-} from '../constants';
-import deepEquals from '../deepEquals';
-import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition';
-import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
-import guessType from '../guessType';
-import isObject from '../isObject';
-import mergeSchemas from '../mergeSchemas';
+} from '../constants.ts';
+import deepEquals from '../deepEquals.ts';
+import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition.ts';
+import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema.ts';
+import guessType from '../guessType.ts';
+import isObject from '../isObject.ts';
+import mergeSchemas from '../mergeSchemas.ts';
+import { getByPath } from '../pathUtils.ts';
 import type {
   Experimental_CustomMergeAllOf,
   FormContextType,
@@ -37,9 +29,9 @@ import type {
   RJSFSchema,
   StrictRJSFSchema,
   ValidatorType,
-} from '../types';
-import getFirstMatchingOption from './getFirstMatchingOption';
-import shallowAllOfMerge from './shallowAllOfMerge';
+} from '../types.ts';
+import getFirstMatchingOption from './getFirstMatchingOption.ts';
+import shallowAllOfMerge from './shallowAllOfMerge.ts';
 
 /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
  * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
@@ -198,7 +190,7 @@ export function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchem
     (permutations, list) => {
       // When there are more than one set of schemas for a row, duplicate the set of permutations and add in the values
       if (list.length > 1) {
-        return list.flatMap((element) => times(permutations.length, (i) => [...permutations[i]].concat(element)));
+        return list.flatMap((element) => permutations.map((permutation) => [...permutation, element]));
       }
       // Otherwise just push in the single value into the current set of permutations
       permutations.forEach((permutation) => permutation.push(list[0]));
@@ -220,16 +212,10 @@ export function getMatchingPatternProperties<S extends StrictRJSFSchema = RJSFSc
   schema: S,
   key: string,
 ): Required<S['patternProperties']> {
-  return Object.keys(schema.patternProperties!)
-    .filter((pattern: string) => RegExp(pattern).test(key))
-    .reduce(
-      (obj, pattern) => {
-        // Pass the pattern using the `[]` index notation so that any `.` in the pattern are not used as a dotted path
-        set(obj, [pattern], schema.patternProperties![pattern]);
-        return obj;
-      },
-      {} as Required<S['patternProperties']>,
-    );
+  const patternProperties = schema.patternProperties ?? {};
+  return Object.fromEntries(
+    Object.entries(patternProperties).filter(([pattern]) => RegExp(pattern).test(key)),
+  ) as Required<S['patternProperties']>;
 }
 
 /** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag
@@ -402,27 +388,28 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
 
   if (PROPERTIES_KEY in resolvedSchema) {
     const childrenLists: string[][] = [];
-    const updatedProps = transform(
-      resolvedSchema[PROPERTIES_KEY]!,
-      (acc, value, key: string) => {
-        const childList: string[] = [...recurseList];
-        // Mark cycles only when NOT in resolveAnyOfOrOneOfRefs mode. When resolveAnyOfOrOneOfRefs=true
-        // (e.g. from ObjectField), options are resolved against a shared recurseList that accumulates
-        // refs across branches, causing false positives. In simple (non-anyOf) resolution, a $ref cycle
-        // in an object property always causes an infinite render loop and must be caught.
-        acc[key] = resolveAllReferences(
-          value as S,
-          rootSchema,
-          childList,
-          currentBaseURI,
-          resolveAnyOfOrOneOfRefs,
-          !resolveAnyOfOrOneOfRefs,
-        );
-        childrenLists.push(childList);
-      },
-      {} as RJSFSchema,
-    );
-    merge(recurseList, uniq(flattenDeep(childrenLists)));
+    const updatedProps: RJSFSchema = {};
+    for (const [key, value] of Object.entries(resolvedSchema[PROPERTIES_KEY] ?? {})) {
+      const childList: string[] = [...recurseList];
+      // Mark cycles only when NOT in resolveAnyOfOrOneOfRefs mode. When resolveAnyOfOrOneOfRefs=true
+      // (e.g. from ObjectField), options are resolved against a shared recurseList that accumulates
+      // refs across branches, causing false positives. In simple (non-anyOf) resolution, a $ref cycle
+      // in an object property always causes an infinite render loop and must be caught.
+      updatedProps[key] = resolveAllReferences(
+        value as S,
+        rootSchema,
+        childList,
+        currentBaseURI,
+        resolveAnyOfOrOneOfRefs,
+        !resolveAnyOfOrOneOfRefs,
+      );
+      childrenLists.push(childList);
+    }
+    for (const ref of new Set(childrenLists.flat())) {
+      if (!recurseList.includes(ref)) {
+        recurseList.push(ref);
+      }
+    }
     resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps };
   }
 
@@ -502,12 +489,12 @@ export function stubExistingAdditionalProperties<
     }
     if (PATTERN_PROPERTIES_KEY in schema) {
       const matchingProperties = getMatchingPatternProperties(schema, key);
-      if (!isEmpty(matchingProperties)) {
+      if (Object.keys(matchingProperties).length > 0) {
         schema.properties[key] = retrieveSchema<T, S, F>(
           validator,
           { [ALL_OF_KEY]: Object.values(matchingProperties) } as S,
           rootSchema,
-          get(formData, [key]) as T,
+          formData[key],
           experimental_customMergeAllOf,
         );
         (schema.properties[key] as RJSFMarkedSchema)[ADDITIONAL_PROPERTY_FLAG] = true;
@@ -520,9 +507,9 @@ export function stubExistingAdditionalProperties<
         if (REF_KEY in schema.additionalProperties!) {
           additionalProperties = retrieveSchema<T, S, F>(
             validator,
-            { [REF_KEY]: get(schema.additionalProperties, [REF_KEY]) } as S,
+            { [REF_KEY]: (schema.additionalProperties as S)[REF_KEY] } as S,
             rootSchema,
-            get(formData, [key]) as T,
+            formData[key],
             experimental_customMergeAllOf,
           );
         } else if ('type' in schema.additionalProperties!) {
@@ -533,10 +520,10 @@ export function stubExistingAdditionalProperties<
             ...schema.additionalProperties,
           };
         } else {
-          additionalProperties = { type: guessType(get(formData, [key])) };
+          additionalProperties = { type: guessType(formData[key]) };
         }
       } else {
-        additionalProperties = { type: guessType(get(formData, [key])) };
+        additionalProperties = { type: guessType(formData[key]) };
       }
 
       // The type of our new key should match the additionalProperties value;
@@ -668,12 +655,12 @@ export function retrieveSchemaInternal<
       resolvedSchema = Object.keys(resolvedSchema.properties!).reduce(
         (acc, key) => {
           const matchingProperties = getMatchingPatternProperties(acc, key);
-          if (!isEmpty(matchingProperties)) {
+          if (Object.keys(matchingProperties).length > 0) {
             acc.properties[key] = retrieveSchema<T, S, F>(
               validator,
               { allOf: [acc.properties[key], ...Object.values(matchingProperties)] } as S,
               rootSchema,
-              get(rawFormData, [key]) as T,
+              getByPath<T>(rawFormData, key),
               experimental_customMergeAllOf,
             );
           }
@@ -850,7 +837,7 @@ export function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSc
   // Process dependencies updating the local schema properties as appropriate.
   for (const dependencyKey in dependencies) {
     if (
-      (expandAllBranches || get(formData, [dependencyKey]) !== undefined) &&
+      (expandAllBranches || getByPath(formData, dependencyKey) !== undefined) &&
       (!resolvedSchema.properties || dependencyKey in resolvedSchema.properties)
     ) {
       const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(